chore: cleanup move private packages to internal (#1665)

installer/files.wxs

@@ -1,4 +1,4 @@
-<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs" xmlns:netfx="http://wixtoolset.org/schemas/v4/wxs/netfx"
+<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs"
      xmlns:util="http://wixtoolset.org/schemas/v4/wxs/util">
     <Fragment>
         <DirectoryRef Id="APPLICATIONFOLDER">

internal/collector/ad/ad.go

@@ -9,7 +9,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perfdata"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus-community/windows_exporter/internal/utils"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
@@ -284,374 +284,374 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	c.wmiClient = wmiClient
 
 	c.addressBookOperationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "address_book_operations_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "address_book_operations_total"),
 		"",
 		[]string{"operation"},
 		nil,
 	)
 	c.addressBookClientSessions = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "address_book_client_sessions"),
+		prometheus.BuildFQName(types.Namespace, Name, "address_book_client_sessions"),
 		"",
 		nil,
 		nil,
 	)
 	c.approximateHighestDistinguishedNameTag = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "approximate_highest_distinguished_name_tag"),
+		prometheus.BuildFQName(types.Namespace, Name, "approximate_highest_distinguished_name_tag"),
 		"",
 		nil,
 		nil,
 	)
 	c.atqEstimatedDelaySeconds = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "atq_estimated_delay_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "atq_estimated_delay_seconds"),
 		"",
 		nil,
 		nil,
 	)
 	c.atqOutstandingRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "atq_outstanding_requests"),
+		prometheus.BuildFQName(types.Namespace, Name, "atq_outstanding_requests"),
 		"",
 		nil,
 		nil,
 	)
 	c.atqAverageRequestLatency = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "atq_average_request_latency"),
+		prometheus.BuildFQName(types.Namespace, Name, "atq_average_request_latency"),
 		"",
 		nil,
 		nil,
 	)
 	c.atqCurrentThreads = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "atq_current_threads"),
+		prometheus.BuildFQName(types.Namespace, Name, "atq_current_threads"),
 		"",
 		[]string{"service"},
 		nil,
 	)
 	c.searchesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "searches_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "searches_total"),
 		"",
 		[]string{"scope"},
 		nil,
 	)
 	c.databaseOperationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "database_operations_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "database_operations_total"),
 		"",
 		[]string{"operation"},
 		nil,
 	)
 	c.bindsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "binds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "binds_total"),
 		"",
 		[]string{"bind_method"},
 		nil,
 	)
 	c.replicationHighestUsn = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_highest_usn"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_highest_usn"),
 		"",
 		[]string{"state"},
 		nil,
 	)
 	c.intraSiteReplicationDataBytesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_data_intrasite_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_data_intrasite_bytes_total"),
 		"",
 		[]string{"direction"},
 		nil,
 	)
 	c.interSiteReplicationDataBytesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_data_intersite_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_data_intersite_bytes_total"),
 		"",
 		[]string{"direction"},
 		nil,
 	)
 	c.replicationInboundSyncObjectsRemaining = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_inbound_sync_objects_remaining"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_inbound_sync_objects_remaining"),
 		"",
 		nil,
 		nil,
 	)
 	c.replicationInboundLinkValueUpdatesRemaining = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_inbound_link_value_updates_remaining"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_inbound_link_value_updates_remaining"),
 		"",
 		nil,
 		nil,
 	)
 	c.replicationInboundObjectsUpdatedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_inbound_objects_updated_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_inbound_objects_updated_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.replicationInboundObjectsFilteredTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_inbound_objects_filtered_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_inbound_objects_filtered_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.replicationInboundPropertiesUpdatedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_inbound_properties_updated_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_inbound_properties_updated_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.replicationInboundPropertiesFilteredTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_inbound_properties_filtered_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_inbound_properties_filtered_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.replicationPendingOperations = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_pending_operations"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_pending_operations"),
 		"",
 		nil,
 		nil,
 	)
 	c.replicationPendingSynchronizations = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_pending_synchronizations"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_pending_synchronizations"),
 		"",
 		nil,
 		nil,
 	)
 	c.replicationSyncRequestsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_sync_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_sync_requests_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.replicationSyncRequestsSuccessTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_sync_requests_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_sync_requests_success_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.replicationSyncRequestsSchemaMismatchFailureTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "replication_sync_requests_schema_mismatch_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "replication_sync_requests_schema_mismatch_failure_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.nameTranslationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "name_translations_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "name_translations_total"),
 		"",
 		[]string{"target_name"},
 		nil,
 	)
 	c.changeMonitorsRegistered = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "change_monitors_registered"),
+		prometheus.BuildFQName(types.Namespace, Name, "change_monitors_registered"),
 		"",
 		nil,
 		nil,
 	)
 	c.changeMonitorUpdatesPending = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "change_monitor_updates_pending"),
+		prometheus.BuildFQName(types.Namespace, Name, "change_monitor_updates_pending"),
 		"",
 		nil,
 		nil,
 	)
 	c.nameCacheHitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "name_cache_hits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "name_cache_hits_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.nameCacheLookupsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "name_cache_lookups_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "name_cache_lookups_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.directoryOperationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "directory_operations_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "directory_operations_total"),
 		"",
 		[]string{"operation", "origin"},
 		nil,
 	)
 	c.directorySearchSubOperationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "directory_search_suboperations_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "directory_search_suboperations_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.securityDescriptorPropagationEventsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "security_descriptor_propagation_events_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "security_descriptor_propagation_events_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.securityDescriptorPropagationEventsQueued = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "security_descriptor_propagation_events_queued"),
+		prometheus.BuildFQName(types.Namespace, Name, "security_descriptor_propagation_events_queued"),
 		"",
 		nil,
 		nil,
 	)
 	c.securityDescriptorPropagationAccessWaitTotalSeconds = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "security_descriptor_propagation_access_wait_total_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "security_descriptor_propagation_access_wait_total_seconds"),
 		"",
 		nil,
 		nil,
 	)
 	c.securityDescriptorPropagationItemsQueuedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "security_descriptor_propagation_items_queued_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "security_descriptor_propagation_items_queued_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.directoryServiceThreads = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "directory_service_threads"),
+		prometheus.BuildFQName(types.Namespace, Name, "directory_service_threads"),
 		"",
 		nil,
 		nil,
 	)
 	c.ldapClosedConnectionsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ldap_closed_connections_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "ldap_closed_connections_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.ldapOpenedConnectionsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ldap_opened_connections_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "ldap_opened_connections_total"),
 		"",
 		[]string{"type"},
 		nil,
 	)
 	c.ldapActiveThreads = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ldap_active_threads"),
+		prometheus.BuildFQName(types.Namespace, Name, "ldap_active_threads"),
 		"",
 		nil,
 		nil,
 	)
 	c.ldapLastBindTimeSeconds = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ldap_last_bind_time_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "ldap_last_bind_time_seconds"),
 		"",
 		nil,
 		nil,
 	)
 	c.ldapSearchesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ldap_searches_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "ldap_searches_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.ldapUdpOperationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ldap_udp_operations_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "ldap_udp_operations_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.ldapWritesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ldap_writes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "ldap_writes_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.ldapClientSessions = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ldap_client_sessions"),
+		prometheus.BuildFQName(types.Namespace, Name, "ldap_client_sessions"),
 		"This is the number of sessions opened by LDAP clients at the time the data is taken. This is helpful in determining LDAP client activity and if the DC is able to handle the load. Of course, spikes during normal periods of authentication — such as first thing in the morning — are not necessarily a problem, but long sustained periods of high values indicate an overworked DC.",
 		nil,
 		nil,
 	)
 	c.linkValuesCleanedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "link_values_cleaned_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "link_values_cleaned_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.phantomObjectsCleanedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "phantom_objects_cleaned_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "phantom_objects_cleaned_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.phantomObjectsVisitedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "phantom_objects_visited_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "phantom_objects_visited_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.samGroupMembershipEvaluationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_group_membership_evaluations_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_group_membership_evaluations_total"),
 		"",
 		[]string{"group_type"},
 		nil,
 	)
 	c.samGroupMembershipGlobalCatalogEvaluationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_group_membership_global_catalog_evaluations_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_group_membership_global_catalog_evaluations_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.samGroupMembershipEvaluationsNonTransitiveTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_group_membership_evaluations_nontransitive_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_group_membership_evaluations_nontransitive_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.samGroupMembershipEvaluationsTransitiveTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_group_membership_evaluations_transitive_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_group_membership_evaluations_transitive_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.samGroupEvaluationLatency = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_group_evaluation_latency"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_group_evaluation_latency"),
 		"The mean latency of the last 100 group evaluations performed for authentication",
 		[]string{"evaluation_type"},
 		nil,
 	)
 	c.samComputerCreationRequestsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_computer_creation_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_computer_creation_requests_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.samComputerCreationSuccessfulRequestsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_computer_creation_successful_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_computer_creation_successful_requests_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.samUserCreationRequestsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_user_creation_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_user_creation_requests_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.samUserCreationSuccessfulRequestsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_user_creation_successful_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_user_creation_successful_requests_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.samQueryDisplayRequestsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_query_display_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_query_display_requests_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.samEnumerationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_enumerations_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_enumerations_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.samMembershipChangesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_membership_changes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_membership_changes_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.samPasswordChangesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sam_password_changes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sam_password_changes_total"),
 		"",
 		nil,
 		nil,
 	)
 
 	c.tombstonesObjectsCollectedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "tombstoned_objects_collected_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "tombstoned_objects_collected_total"),
 		"",
 		nil,
 		nil,
 	)
 	c.tombstonesObjectsVisitedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "tombstoned_objects_visited_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "tombstoned_objects_visited_total"),
 		"",
 		nil,
 		nil,
@@ -662,7 +662,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	if utils.PDHEnabled() {
 		return c.collectPDH(ch)
 	}

internal/collector/adcs/adcs.go

@@ -10,7 +10,7 @@ import (
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perfdata"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus-community/windows_exporter/internal/utils"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
@@ -101,79 +101,79 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	}
 
 	c.requestsPerSecond = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "requests_total"),
 		"Total certificate requests processed",
 		[]string{"cert_template"},
 		nil,
 	)
 	c.requestProcessingTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "request_processing_time_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "request_processing_time_seconds"),
 		"Last time elapsed for certificate requests",
 		[]string{"cert_template"},
 		nil,
 	)
 	c.retrievalsPerSecond = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "retrievals_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "retrievals_total"),
 		"Total certificate retrieval requests processed",
 		[]string{"cert_template"},
 		nil,
 	)
 	c.retrievalProcessingTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "retrievals_processing_time_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "retrievals_processing_time_seconds"),
 		"Last time elapsed for certificate retrieval request",
 		[]string{"cert_template"},
 		nil,
 	)
 	c.failedRequestsPerSecond = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "failed_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "failed_requests_total"),
 		"Total failed certificate requests processed",
 		[]string{"cert_template"},
 		nil,
 	)
 	c.issuedRequestsPerSecond = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "issued_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "issued_requests_total"),
 		"Total issued certificate requests processed",
 		[]string{"cert_template"},
 		nil,
 	)
 	c.pendingRequestsPerSecond = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pending_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "pending_requests_total"),
 		"Total pending certificate requests processed",
 		[]string{"cert_template"},
 		nil,
 	)
 	c.requestCryptographicSigningTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "request_cryptographic_signing_time_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "request_cryptographic_signing_time_seconds"),
 		"Last time elapsed for signing operation request",
 		[]string{"cert_template"},
 		nil,
 	)
 	c.requestPolicyModuleProcessingTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "request_policy_module_processing_time_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "request_policy_module_processing_time_seconds"),
 		"Last time elapsed for policy module processing request",
 		[]string{"cert_template"},
 		nil,
 	)
 	c.challengeResponsesPerSecond = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "challenge_responses_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "challenge_responses_total"),
 		"Total certificate challenge responses processed",
 		[]string{"cert_template"},
 		nil,
 	)
 	c.challengeResponseProcessingTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "challenge_response_processing_time_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "challenge_response_processing_time_seconds"),
 		"Last time elapsed for challenge response",
 		[]string{"cert_template"},
 		nil,
 	)
 	c.signedCertificateTimestampListsPerSecond = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "signed_certificate_timestamp_lists_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "signed_certificate_timestamp_lists_total"),
 		"Total Signed Certificate Timestamp Lists processed",
 		[]string{"cert_template"},
 		nil,
 	)
 	c.signedCertificateTimestampListProcessingTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "signed_certificate_timestamp_list_processing_time_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "signed_certificate_timestamp_list_processing_time_seconds"),
 		"Last time elapsed for Signed Certificate Timestamp List",
 		[]string{"cert_template"},
 		nil,
@@ -182,7 +182,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	return nil
 }
 
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	if utils.PDHEnabled() {
 		return c.collectPDH(ch)
 	}
@@ -199,7 +199,7 @@ func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch c
 	return nil
 }
 
-func (c *Collector) collectADCSCounters(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectADCSCounters(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	dst := make([]perflibADCS, 0)
 
 	if _, ok := ctx.PerfObjects["Certification Authority"]; !ok {

internal/collector/adcs/adcs_test.go

@@ -3,10 +3,10 @@ package adcs_test
 import (
 	"testing"
 
-	adcs2 "github.com/prometheus-community/windows_exporter/internal/collector/adcs"
+	"github.com/prometheus-community/windows_exporter/internal/collector/adcs"
 	"github.com/prometheus-community/windows_exporter/internal/testutils"
 )
 
 func BenchmarkCollector(b *testing.B) {
-	testutils.FuncBenchmarkCollector(b, adcs2.Name, adcs2.NewWithFlags)
+	testutils.FuncBenchmarkCollector(b, adcs.Name, adcs.NewWithFlags)
 }

internal/collector/adfs/adfs.go

@@ -13,7 +13,7 @@ import (
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perfdata"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus-community/windows_exporter/internal/utils"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
@@ -164,259 +164,259 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	}
 
 	c.adLoginConnectionFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ad_login_connection_failures_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "ad_login_connection_failures_total"),
 		"Total number of connection failures to an Active Directory domain controller",
 		nil,
 		nil,
 	)
 	c.certificateAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "certificate_authentications_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "certificate_authentications_total"),
 		"Total number of User Certificate authentications",
 		nil,
 		nil,
 	)
 	c.deviceAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "device_authentications_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "device_authentications_total"),
 		"Total number of Device authentications",
 		nil,
 		nil,
 	)
 	c.extranetAccountLockouts = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "extranet_account_lockouts_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "extranet_account_lockouts_total"),
 		"Total number of Extranet Account Lockouts",
 		nil,
 		nil,
 	)
 	c.federatedAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "federated_authentications_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "federated_authentications_total"),
 		"Total number of authentications from a federated source",
 		nil,
 		nil,
 	)
 	c.passportAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "passport_authentications_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "passport_authentications_total"),
 		"Total number of Microsoft Passport SSO authentications",
 		nil,
 		nil,
 	)
 	c.passiveRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "passive_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "passive_requests_total"),
 		"Total number of passive (browser-based) requests",
 		nil,
 		nil,
 	)
 	c.passwordChangeFailed = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "password_change_failed_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "password_change_failed_total"),
 		"Total number of failed password changes",
 		nil,
 		nil,
 	)
 	c.passwordChangeSucceeded = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "password_change_succeeded_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "password_change_succeeded_total"),
 		"Total number of successful password changes",
 		nil,
 		nil,
 	)
 	c.tokenRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "token_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "token_requests_total"),
 		"Total number of token requests",
 		nil,
 		nil,
 	)
 	c.windowsIntegratedAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "windows_integrated_authentications_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "windows_integrated_authentications_total"),
 		"Total number of Windows integrated authentications (Kerberos/NTLM)",
 		nil,
 		nil,
 	)
 	c.oAuthAuthZRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_authorization_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_authorization_requests_total"),
 		"Total number of incoming requests to the OAuth Authorization endpoint",
 		nil,
 		nil,
 	)
 	c.oAuthClientAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_client_authentication_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_client_authentication_success_total"),
 		"Total number of successful OAuth client Authentications",
 		nil,
 		nil,
 	)
 	c.oAuthClientAuthenticationsFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_client_authentication_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_client_authentication_failure_total"),
 		"Total number of failed OAuth client Authentications",
 		nil,
 		nil,
 	)
 	c.oAuthClientCredentialsRequestFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_client_credentials_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_client_credentials_failure_total"),
 		"Total number of failed OAuth Client Credentials Requests",
 		nil,
 		nil,
 	)
 	c.oAuthClientCredentialsRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_client_credentials_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_client_credentials_success_total"),
 		"Total number of successful RP tokens issued for OAuth Client Credentials Requests",
 		nil,
 		nil,
 	)
 	c.oAuthClientPrivateKeyJwtAuthenticationFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_client_privkey_jwt_authentication_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_client_privkey_jwt_authentication_failure_total"),
 		"Total number of failed OAuth Client Private Key Jwt Authentications",
 		nil,
 		nil,
 	)
 	c.oAuthClientPrivateKeyJwtAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_client_privkey_jwt_authentications_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_client_privkey_jwt_authentications_success_total"),
 		"Total number of successful OAuth Client Private Key Jwt Authentications",
 		nil,
 		nil,
 	)
 	c.oAuthClientSecretBasicAuthenticationFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_client_secret_basic_authentications_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_client_secret_basic_authentications_failure_total"),
 		"Total number of failed OAuth Client Secret Basic Authentications",
 		nil,
 		nil,
 	)
 	c.oAuthClientSecretBasicAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_client_secret_basic_authentications_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_client_secret_basic_authentications_success_total"),
 		"Total number of successful OAuth Client Secret Basic Authentications",
 		nil,
 		nil,
 	)
 	c.oAuthClientSecretPostAuthenticationFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_client_secret_post_authentications_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_client_secret_post_authentications_failure_total"),
 		"Total number of failed OAuth Client Secret Post Authentications",
 		nil,
 		nil,
 	)
 	c.oAuthClientSecretPostAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_client_secret_post_authentications_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_client_secret_post_authentications_success_total"),
 		"Total number of successful OAuth Client Secret Post Authentications",
 		nil,
 		nil,
 	)
 	c.oAuthClientWindowsIntegratedAuthenticationFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_client_windows_authentications_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_client_windows_authentications_failure_total"),
 		"Total number of failed OAuth Client Windows Integrated Authentications",
 		nil,
 		nil,
 	)
 	c.oAuthClientWindowsIntegratedAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_client_windows_authentications_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_client_windows_authentications_success_total"),
 		"Total number of successful OAuth Client Windows Integrated Authentications",
 		nil,
 		nil,
 	)
 	c.oAuthLogonCertificateRequestFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_logon_certificate_requests_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_logon_certificate_requests_failure_total"),
 		"Total number of failed OAuth Logon Certificate Requests",
 		nil,
 		nil,
 	)
 	c.oAuthLogonCertificateTokenRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_logon_certificate_token_requests_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_logon_certificate_token_requests_success_total"),
 		"Total number of successful RP tokens issued for OAuth Logon Certificate Requests",
 		nil,
 		nil,
 	)
 	c.oAuthPasswordGrantRequestFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_password_grant_requests_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_password_grant_requests_failure_total"),
 		"Total number of failed OAuth Password Grant Requests",
 		nil,
 		nil,
 	)
 	c.oAuthPasswordGrantRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_password_grant_requests_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_password_grant_requests_success_total"),
 		"Total number of successful OAuth Password Grant Requests",
 		nil,
 		nil,
 	)
 	c.oAuthTokenRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "oauth_token_requests_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "oauth_token_requests_success_total"),
 		"Total number of successful RP tokens issued over OAuth protocol",
 		nil,
 		nil,
 	)
 	c.samlPTokenRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "samlp_token_requests_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "samlp_token_requests_success_total"),
 		"Total number of successful RP tokens issued over SAML-P protocol",
 		nil,
 		nil,
 	)
 	c.ssoAuthenticationFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sso_authentications_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sso_authentications_failure_total"),
 		"Total number of failed SSO authentications",
 		nil,
 		nil,
 	)
 	c.ssoAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sso_authentications_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sso_authentications_success_total"),
 		"Total number of successful SSO authentications",
 		nil,
 		nil,
 	)
 	c.wsFedTokenRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "wsfed_token_requests_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "wsfed_token_requests_success_total"),
 		"Total number of successful RP tokens issued over WS-Fed protocol",
 		nil,
 		nil,
 	)
 	c.wsTrustTokenRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "wstrust_token_requests_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "wstrust_token_requests_success_total"),
 		"Total number of successful RP tokens issued over WS-Trust protocol",
 		nil,
 		nil,
 	)
 	c.upAuthenticationFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "userpassword_authentications_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "userpassword_authentications_failure_total"),
 		"Total number of failed AD U/P authentications",
 		nil,
 		nil,
 	)
 	c.upAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "userpassword_authentications_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "userpassword_authentications_success_total"),
 		"Total number of successful AD U/P authentications",
 		nil,
 		nil,
 	)
 	c.externalAuthenticationFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "external_authentications_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "external_authentications_failure_total"),
 		"Total number of failed authentications from external MFA providers",
 		nil,
 		nil,
 	)
 	c.externalAuthentications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "external_authentications_success_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "external_authentications_success_total"),
 		"Total number of successful authentications from external MFA providers",
 		nil,
 		nil,
 	)
 	c.artifactDBFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "db_artifact_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "db_artifact_failure_total"),
 		"Total number of failures connecting to the artifact database",
 		nil,
 		nil,
 	)
 	c.avgArtifactDBQueryTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "db_artifact_query_time_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "db_artifact_query_time_seconds_total"),
 		"Accumulator of time taken for an artifact database query",
 		nil,
 		nil,
 	)
 	c.configDBFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "db_config_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "db_config_failure_total"),
 		"Total number of failures connecting to the configuration database",
 		nil,
 		nil,
 	)
 	c.avgConfigDBQueryTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "db_config_query_time_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "db_config_query_time_seconds_total"),
 		"Accumulator of time taken for a configuration database query",
 		nil,
 		nil,
 	)
 	c.federationMetadataRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "federation_metadata_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "federation_metadata_requests_total"),
 		"Total number of Federation Metadata requests",
 		nil,
 		nil,
@@ -425,7 +425,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	return nil
 }
 
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	if utils.PDHEnabled() {
 		return c.collectPDH(ch)
 	}
@@ -435,7 +435,7 @@ func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch c
 	return c.collect(ctx, logger, ch)
 }
 
-func (c *Collector) collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	var adfsData []perflibADFS
 
 	err := perflib.UnmarshalObject(ctx.PerfObjects["AD FS"], &adfsData, logger)

internal/collector/cache/cache.go

@@ -10,7 +10,7 @@ import (
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perfdata"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus-community/windows_exporter/internal/utils"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
@@ -134,175 +134,175 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	}
 
 	c.asyncCopyReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "async_copy_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "async_copy_reads_total"),
 		"(AsyncCopyReadsTotal)",
 		nil,
 		nil,
 	)
 	c.asyncDataMapsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "async_data_maps_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "async_data_maps_total"),
 		"(AsyncDataMapsTotal)",
 		nil,
 		nil,
 	)
 	c.asyncFastReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "async_fast_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "async_fast_reads_total"),
 		"(AsyncFastReadsTotal)",
 		nil,
 		nil,
 	)
 	c.asyncMDLReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "async_mdl_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "async_mdl_reads_total"),
 		"(AsyncMDLReadsTotal)",
 		nil,
 		nil,
 	)
 	c.asyncPinReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "async_pin_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "async_pin_reads_total"),
 		"(AsyncPinReadsTotal)",
 		nil,
 		nil,
 	)
 	c.copyReadHitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "copy_read_hits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "copy_read_hits_total"),
 		"(CopyReadHitsTotal)",
 		nil,
 		nil,
 	)
 	c.copyReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "copy_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "copy_reads_total"),
 		"(CopyReadsTotal)",
 		nil,
 		nil,
 	)
 	c.dataFlushesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "data_flushes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "data_flushes_total"),
 		"(DataFlushesTotal)",
 		nil,
 		nil,
 	)
 	c.dataFlushPagesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "data_flush_pages_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "data_flush_pages_total"),
 		"(DataFlushPagesTotal)",
 		nil,
 		nil,
 	)
 	c.dataMapHitsPercent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "data_map_hits_percent"),
+		prometheus.BuildFQName(types.Namespace, Name, "data_map_hits_percent"),
 		"(DataMapHitsPercent)",
 		nil,
 		nil,
 	)
 	c.dataMapPinsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "data_map_pins_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "data_map_pins_total"),
 		"(DataMapPinsTotal)",
 		nil,
 		nil,
 	)
 	c.dataMapsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "data_maps_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "data_maps_total"),
 		"(DataMapsTotal)",
 		nil,
 		nil,
 	)
 	c.dirtyPages = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "dirty_pages"),
+		prometheus.BuildFQName(types.Namespace, Name, "dirty_pages"),
 		"(DirtyPages)",
 		nil,
 		nil,
 	)
 	c.dirtyPageThreshold = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "dirty_page_threshold"),
+		prometheus.BuildFQName(types.Namespace, Name, "dirty_page_threshold"),
 		"(DirtyPageThreshold)",
 		nil,
 		nil,
 	)
 	c.fastReadNotPossiblesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "fast_read_not_possibles_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "fast_read_not_possibles_total"),
 		"(FastReadNotPossiblesTotal)",
 		nil,
 		nil,
 	)
 	c.fastReadResourceMissesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "fast_read_resource_misses_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "fast_read_resource_misses_total"),
 		"(FastReadResourceMissesTotal)",
 		nil,
 		nil,
 	)
 	c.fastReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "fast_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "fast_reads_total"),
 		"(FastReadsTotal)",
 		nil,
 		nil,
 	)
 	c.lazyWriteFlushesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "lazy_write_flushes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "lazy_write_flushes_total"),
 		"(LazyWriteFlushesTotal)",
 		nil,
 		nil,
 	)
 	c.lazyWritePagesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "lazy_write_pages_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "lazy_write_pages_total"),
 		"(LazyWritePagesTotal)",
 		nil,
 		nil,
 	)
 	c.mdlReadHitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mdl_read_hits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "mdl_read_hits_total"),
 		"(MDLReadHitsTotal)",
 		nil,
 		nil,
 	)
 	c.mdlReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mdl_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "mdl_reads_total"),
 		"(MDLReadsTotal)",
 		nil,
 		nil,
 	)
 	c.pinReadHitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pin_read_hits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "pin_read_hits_total"),
 		"(PinReadHitsTotal)",
 		nil,
 		nil,
 	)
 	c.pinReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pin_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "pin_reads_total"),
 		"(PinReadsTotal)",
 		nil,
 		nil,
 	)
 	c.readAheadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "read_aheads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "read_aheads_total"),
 		"(ReadAheadsTotal)",
 		nil,
 		nil,
 	)
 	c.syncCopyReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sync_copy_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sync_copy_reads_total"),
 		"(SyncCopyReadsTotal)",
 		nil,
 		nil,
 	)
 	c.syncDataMapsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sync_data_maps_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sync_data_maps_total"),
 		"(SyncDataMapsTotal)",
 		nil,
 		nil,
 	)
 	c.syncFastReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sync_fast_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sync_fast_reads_total"),
 		"(SyncFastReadsTotal)",
 		nil,
 		nil,
 	)
 	c.syncMDLReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sync_mdl_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sync_mdl_reads_total"),
 		"(SyncMDLReadsTotal)",
 		nil,
 		nil,
 	)
 	c.syncPinReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sync_pin_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sync_pin_reads_total"),
 		"(SyncPinReadsTotal)",
 		nil,
 		nil,
@@ -312,7 +312,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 }
 
 // Collect implements the Collector interface.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	if utils.PDHEnabled() {
 		return c.collectPDH(ch)
 	}
@@ -329,7 +329,7 @@ func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch c
 	return nil
 }
 
-func (c *Collector) collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	var dst []perflibCache // Single-instance class, array is required but will have single entry.
 
 	if err := perflib.UnmarshalObject(ctx.PerfObjects["Cache"], &dst, logger); err != nil {

internal/collector/container/container.go

@@ -11,7 +11,7 @@ import (
 	"github.com/Microsoft/hcsshim"
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -88,109 +88,109 @@ func (c *Collector) Close(_ *slog.Logger) error {
 
 func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	c.containerAvailable = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "available"),
+		prometheus.BuildFQName(types.Namespace, Name, "available"),
 		"Available",
 		[]string{"container_id"},
 		nil,
 	)
 	c.containersCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "count"),
+		prometheus.BuildFQName(types.Namespace, Name, "count"),
 		"Number of containers",
 		nil,
 		nil,
 	)
 	c.usageCommitBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "memory_usage_commit_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "memory_usage_commit_bytes"),
 		"Memory Usage Commit Bytes",
 		[]string{"container_id"},
 		nil,
 	)
 	c.usageCommitPeakBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "memory_usage_commit_peak_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "memory_usage_commit_peak_bytes"),
 		"Memory Usage Commit Peak Bytes",
 		[]string{"container_id"},
 		nil,
 	)
 	c.usagePrivateWorkingSetBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "memory_usage_private_working_set_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "memory_usage_private_working_set_bytes"),
 		"Memory Usage Private Working Set Bytes",
 		[]string{"container_id"},
 		nil,
 	)
 	c.runtimeTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cpu_usage_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cpu_usage_seconds_total"),
 		"Total Run time in Seconds",
 		[]string{"container_id"},
 		nil,
 	)
 	c.runtimeUser = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cpu_usage_seconds_usermode"),
+		prometheus.BuildFQName(types.Namespace, Name, "cpu_usage_seconds_usermode"),
 		"Run Time in User mode in Seconds",
 		[]string{"container_id"},
 		nil,
 	)
 	c.runtimeKernel = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cpu_usage_seconds_kernelmode"),
+		prometheus.BuildFQName(types.Namespace, Name, "cpu_usage_seconds_kernelmode"),
 		"Run time in Kernel mode in Seconds",
 		[]string{"container_id"},
 		nil,
 	)
 	c.bytesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "network_receive_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "network_receive_bytes_total"),
 		"Bytes Received on Interface",
 		[]string{"container_id", "interface"},
 		nil,
 	)
 	c.bytesSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "network_transmit_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "network_transmit_bytes_total"),
 		"Bytes Sent on Interface",
 		[]string{"container_id", "interface"},
 		nil,
 	)
 	c.packetsReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "network_receive_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "network_receive_packets_total"),
 		"Packets Received on Interface",
 		[]string{"container_id", "interface"},
 		nil,
 	)
 	c.packetsSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "network_transmit_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "network_transmit_packets_total"),
 		"Packets Sent on Interface",
 		[]string{"container_id", "interface"},
 		nil,
 	)
 	c.droppedPacketsIncoming = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "network_receive_packets_dropped_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "network_receive_packets_dropped_total"),
 		"Dropped Incoming Packets on Interface",
 		[]string{"container_id", "interface"},
 		nil,
 	)
 	c.droppedPacketsOutgoing = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "network_transmit_packets_dropped_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "network_transmit_packets_dropped_total"),
 		"Dropped Outgoing Packets on Interface",
 		[]string{"container_id", "interface"},
 		nil,
 	)
 	c.readCountNormalized = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "storage_read_count_normalized_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "storage_read_count_normalized_total"),
 		"Read Count Normalized",
 		[]string{"container_id"},
 		nil,
 	)
 	c.readSizeBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "storage_read_size_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "storage_read_size_bytes_total"),
 		"Read Size Bytes",
 		[]string{"container_id"},
 		nil,
 	)
 	c.writeCountNormalized = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "storage_write_count_normalized_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "storage_write_count_normalized_total"),
 		"Write Count Normalized",
 		[]string{"container_id"},
 		nil,
 	)
 	c.writeSizeBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "storage_write_size_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "storage_write_size_bytes_total"),
 		"Write Size Bytes",
 		[]string{"container_id"},
 		nil,
@@ -201,7 +201,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(logger, ch); err != nil {
 		logger.Error("failed collecting collector metrics",

internal/collector/cpu/cpu.go

@@ -10,7 +10,7 @@ import (
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perfdata"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus-community/windows_exporter/internal/utils"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
@@ -120,110 +120,110 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	}
 
 	c.logicalProcessors = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "logical_processor"),
+		prometheus.BuildFQName(types.Namespace, Name, "logical_processor"),
 		"Total number of logical processors",
 		nil,
 		nil,
 	)
 
 	c.cStateSecondsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cstate_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cstate_seconds_total"),
 		"Time spent in low-power idle state",
 		[]string{"core", "state"},
 		nil,
 	)
 	c.timeTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "time_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "time_total"),
 		"Time that processor spent in different modes (dpc, idle, interrupt, privileged, user)",
 		[]string{"core", "mode"},
 		nil,
 	)
 	c.interruptsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "interrupts_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "interrupts_total"),
 		"Total number of received and serviced hardware interrupts",
 		[]string{"core"},
 		nil,
 	)
 	c.dpcsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "dpcs_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "dpcs_total"),
 		"Total number of received and serviced deferred procedure calls (DPCs)",
 		[]string{"core"},
 		nil,
 	)
 	c.cStateSecondsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cstate_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cstate_seconds_total"),
 		"Time spent in low-power idle state",
 		[]string{"core", "state"},
 		nil,
 	)
 	c.timeTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "time_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "time_total"),
 		"Time that processor spent in different modes (dpc, idle, interrupt, privileged, user)",
 		[]string{"core", "mode"},
 		nil,
 	)
 	c.interruptsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "interrupts_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "interrupts_total"),
 		"Total number of received and serviced hardware interrupts",
 		[]string{"core"},
 		nil,
 	)
 	c.dpcsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "dpcs_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "dpcs_total"),
 		"Total number of received and serviced deferred procedure calls (DPCs)",
 		[]string{"core"},
 		nil,
 	)
 	c.clockInterruptsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "clock_interrupts_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "clock_interrupts_total"),
 		"Total number of received and serviced clock tick interrupts",
 		[]string{"core"},
 		nil,
 	)
 	c.idleBreakEventsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "idle_break_events_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "idle_break_events_total"),
 		"Total number of time processor was woken from idle",
 		[]string{"core"},
 		nil,
 	)
 	c.parkingStatus = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "parking_status"),
+		prometheus.BuildFQName(types.Namespace, Name, "parking_status"),
 		"Parking Status represents whether a processor is parked or not",
 		[]string{"core"},
 		nil,
 	)
 	c.processorFrequencyMHz = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "core_frequency_mhz"),
+		prometheus.BuildFQName(types.Namespace, Name, "core_frequency_mhz"),
 		"Core frequency in megahertz",
 		[]string{"core"},
 		nil,
 	)
 	c.processorPerformance = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "processor_performance_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "processor_performance_total"),
 		"Processor Performance is the average performance of the processor while it is executing instructions, as a percentage of the nominal performance of the processor. On some processors, Processor Performance may exceed 100%",
 		[]string{"core"},
 		nil,
 	)
 	c.processorMPerf = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "processor_mperf_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "processor_mperf_total"),
 		"Processor MPerf is the number of TSC ticks incremented while executing instructions",
 		[]string{"core"},
 		nil,
 	)
 	c.processorRTC = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "processor_rtc_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "processor_rtc_total"),
 		"Processor RTC represents the number of RTC ticks made since the system booted. It should consistently be 64e6, and can be used to properly derive Processor Utility Rate",
 		[]string{"core"},
 		nil,
 	)
 	c.processorUtility = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "processor_utility_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "processor_utility_total"),
 		"Processor Utility represents is the amount of time the core spends executing instructions",
 		[]string{"core"},
 		nil,
 	)
 	c.processorPrivilegedUtility = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "processor_privileged_utility_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "processor_privileged_utility_total"),
 		"Processor Privileged Utility represents is the amount of time the core has spent executing instructions inside the kernel",
 		[]string{"core"},
 		nil,
@@ -235,7 +235,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	return nil
 }
 
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	if utils.PDHEnabled() {
 		return c.collectPDH(ch)
 	}
@@ -245,7 +245,7 @@ func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch c
 	return c.collectFull(ctx, logger, ch)
 }
 
-func (c *Collector) collectFull(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectFull(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	data := make([]perflibProcessorInformation, 0)
 
 	err := perflib.UnmarshalObject(ctx.PerfObjects["Processor Information"], &data, logger)

internal/collector/cpu_info/cpu_info.go

@@ -9,7 +9,7 @@ import (
 	"strings"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -70,7 +70,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 	c.wmiClient = wmiClient
 	c.cpuInfo = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, "", Name),
+		prometheus.BuildFQName(types.Namespace, "", Name),
 		"Labelled CPU information as provided by Win32_Processor",
 		[]string{
 			"architecture",
@@ -82,7 +82,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 		nil,
 	)
 	c.cpuThreadCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "thread"),
+		prometheus.BuildFQName(types.Namespace, Name, "thread"),
 		"Number of threads per CPU",
 		[]string{
 			"device_id",
@@ -90,7 +90,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 		nil,
 	)
 	c.cpuCoreCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "core"),
+		prometheus.BuildFQName(types.Namespace, Name, "core"),
 		"Number of cores per CPU",
 		[]string{
 			"device_id",
@@ -98,7 +98,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 		nil,
 	)
 	c.cpuEnabledCoreCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "enabled_core"),
+		prometheus.BuildFQName(types.Namespace, Name, "enabled_core"),
 		"Number of enabled cores per CPU",
 		[]string{
 			"device_id",
@@ -106,7 +106,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 		nil,
 	)
 	c.cpuLogicalProcessorsCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "logical_processor"),
+		prometheus.BuildFQName(types.Namespace, Name, "logical_processor"),
 		"Number of logical processors per CPU",
 		[]string{
 			"device_id",
@@ -114,7 +114,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 		nil,
 	)
 	c.cpuL2CacheSize = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "l2_cache_size"),
+		prometheus.BuildFQName(types.Namespace, Name, "l2_cache_size"),
 		"Size of L2 cache per CPU",
 		[]string{
 			"device_id",
@@ -122,7 +122,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 		nil,
 	)
 	c.cpuL3CacheSize = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "l3_cache_size"),
+		prometheus.BuildFQName(types.Namespace, Name, "l3_cache_size"),
 		"Size of L3 cache per CPU",
 		[]string{
 			"device_id",
@@ -149,7 +149,7 @@ type win32Processor struct {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ch); err != nil {
 		logger.Error("failed collecting cpu_info metrics",

internal/collector/cs/cs.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/headers/sysinfoapi"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -68,19 +68,19 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 		"Hostname has been moved to os collector.")
 
 	c.logicalProcessors = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "logical_processors"),
+		prometheus.BuildFQName(types.Namespace, Name, "logical_processors"),
 		"Deprecated: Use windows_cpu_logical_processor instead",
 		nil,
 		nil,
 	)
 	c.physicalMemoryBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "physical_memory_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "physical_memory_bytes"),
 		"Deprecated: Use windows_physical_memory_total_bytes instead",
 		nil,
 		nil,
 	)
 	c.hostname = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "hostname"),
+		prometheus.BuildFQName(types.Namespace, Name, "hostname"),
 		"Deprecated: Use windows_os_hostname instead",
 		[]string{
 			"hostname",
@@ -95,7 +95,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	if err := c.collect(ch); err != nil {

internal/collector/dfsr/dfsr.go

@@ -12,7 +12,7 @@ import (
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perfdata"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus-community/windows_exporter/internal/utils"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
@@ -87,7 +87,7 @@ type Collector struct {
 	dfsrChildCollectors []dfsrCollectorFunc
 }
 
-type dfsrCollectorFunc func(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error
+type dfsrCollectorFunc func(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error
 
 // Map Perflib sources to DFSR Collector names
 // e.g, volume -> DFS Replication Service Volumes.
@@ -250,63 +250,63 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 	// connection
 	c.connectionBandwidthSavingsUsingDFSReplicationTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_bandwidth_savings_using_dfs_replication_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_bandwidth_savings_using_dfs_replication_bytes_total"),
 		"Total bytes of bandwidth saved using DFS Replication for this connection",
 		[]string{"name"},
 		nil,
 	)
 
 	c.connectionBytesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_bytes_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_bytes_received_total"),
 		"Total bytes received for connection",
 		[]string{"name"},
 		nil,
 	)
 
 	c.connectionCompressedSizeOfFilesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_compressed_size_of_files_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_compressed_size_of_files_received_bytes_total"),
 		"Total compressed size of files received on the connection, in bytes",
 		[]string{"name"},
 		nil,
 	)
 
 	c.connectionFilesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_received_files_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_received_files_total"),
 		"Total number of files received for connection",
 		[]string{"name"},
 		nil,
 	)
 
 	c.connectionRDCBytesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_rdc_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_rdc_received_bytes_total"),
 		"Total bytes received on the connection while replicating files using Remote Differential Compression",
 		[]string{"name"},
 		nil,
 	)
 
 	c.connectionRDCCompressedSizeOfFilesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_rdc_compressed_size_of_received_files_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_rdc_compressed_size_of_received_files_bytes_total"),
 		"Total uncompressed size of files received with Remote Differential Compression for connection",
 		[]string{"name"},
 		nil,
 	)
 
 	c.connectionRDCNumberOfFilesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_rdc_received_files_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_rdc_received_files_total"),
 		"Total number of files received using remote differential compression",
 		[]string{"name"},
 		nil,
 	)
 
 	c.connectionRDCSizeOfFilesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_rdc_size_of_received_files_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_rdc_size_of_received_files_bytes_total"),
 		"Total size of received Remote Differential Compression files, in bytes.",
 		[]string{"name"},
 		nil,
 	)
 
 	c.connectionSizeOfFilesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_files_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_files_received_bytes_total"),
 		"Total size of files received, in bytes",
 		[]string{"name"},
 		nil,
@@ -314,189 +314,189 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 	// folder
 	c.folderBandwidthSavingsUsingDFSReplicationTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_bandwidth_savings_using_dfs_replication_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_bandwidth_savings_using_dfs_replication_bytes_total"),
 		"Total bytes of bandwidth saved using DFS Replication for this folder",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderCompressedSizeOfFilesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_compressed_size_of_received_files_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_compressed_size_of_received_files_bytes_total"),
 		"Total compressed size of files received on the folder, in bytes",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderConflictBytesCleanedUpTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_conflict_cleaned_up_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_conflict_cleaned_up_bytes_total"),
 		"Total size of conflict loser files and folders deleted from the Conflict and Deleted folder, in bytes",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderConflictBytesGeneratedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_conflict_generated_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_conflict_generated_bytes_total"),
 		"Total size of conflict loser files and folders moved to the Conflict and Deleted folder, in bytes",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderConflictFilesCleanedUpTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_conflict_cleaned_up_files_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_conflict_cleaned_up_files_total"),
 		"Number of conflict loser files deleted from the Conflict and Deleted folder",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderConflictFilesGeneratedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_conflict_generated_files_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_conflict_generated_files_total"),
 		"Number of files and folders moved to the Conflict and Deleted folder",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderConflictFolderCleanupsCompletedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_conflict_folder_cleanups_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_conflict_folder_cleanups_total"),
 		"Number of deletions of conflict loser files and folders in the Conflict and Deleted",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderConflictSpaceInUse = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_conflict_space_in_use_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_conflict_space_in_use_bytes"),
 		"Total size of the conflict loser files and folders currently in the Conflict and Deleted folder",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderDeletedSpaceInUse = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_deleted_space_in_use_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_deleted_space_in_use_bytes"),
 		"Total size (in bytes) of the deleted files and folders currently in the Conflict and Deleted folder",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderDeletedBytesCleanedUpTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_deleted_cleaned_up_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_deleted_cleaned_up_bytes_total"),
 		"Total size (in bytes) of replicating deleted files and folders that were cleaned up from the Conflict and Deleted folder",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderDeletedBytesGeneratedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_deleted_generated_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_deleted_generated_bytes_total"),
 		"Total size (in bytes) of replicated deleted files and folders that were moved to the Conflict and Deleted folder after they were deleted from a replicated folder on a sending member",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderDeletedFilesCleanedUpTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_deleted_cleaned_up_files_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_deleted_cleaned_up_files_total"),
 		"Number of files and folders that were cleaned up from the Conflict and Deleted folder",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderDeletedFilesGeneratedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_deleted_generated_files_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_deleted_generated_files_total"),
 		"Number of deleted files and folders that were moved to the Conflict and Deleted folder",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderFileInstallsRetriedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_file_installs_retried_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_file_installs_retried_total"),
 		"Total number of file installs that are being retried due to sharing violations or other errors encountered when installing the files",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderFileInstallsSucceededTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_file_installs_succeeded_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_file_installs_succeeded_total"),
 		"Total number of files that were successfully received from sending members and installed locally on this server",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderFilesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_received_files_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_received_files_total"),
 		"Total number of files received",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderRDCBytesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_rdc_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_rdc_received_bytes_total"),
 		"Total number of bytes received in replicating files using Remote Differential Compression",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderRDCCompressedSizeOfFilesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_rdc_compressed_size_of_received_files_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_rdc_compressed_size_of_received_files_bytes_total"),
 		"Total compressed size (in bytes) of the files received with Remote Differential Compression",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderRDCNumberOfFilesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_rdc_received_files_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_rdc_received_files_total"),
 		"Total number of files received with Remote Differential Compression",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderRDCSizeOfFilesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_rdc_files_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_rdc_files_received_bytes_total"),
 		"Total uncompressed size (in bytes) of the files received with Remote Differential Compression",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderSizeOfFilesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_files_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_files_received_bytes_total"),
 		"Total uncompressed size (in bytes) of the files received",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderStagingSpaceInUse = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_staging_space_in_use_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_staging_space_in_use_bytes"),
 		"Total size of files and folders currently in the staging folder.",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderStagingBytesCleanedUpTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_staging_cleaned_up_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_staging_cleaned_up_bytes_total"),
 		"Total size (in bytes) of the files and folders that have been cleaned up from the staging folder",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderStagingBytesGeneratedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_staging_generated_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_staging_generated_bytes_total"),
 		"Total size (in bytes) of replicated files and folders in the staging folder created by the DFS Replication service since last restart",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderStagingFilesCleanedUpTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_staging_cleaned_up_files_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_staging_cleaned_up_files_total"),
 		"Total number of files and folders that have been cleaned up from the staging folder",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderStagingFilesGeneratedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_staging_generated_files_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_staging_generated_files_total"),
 		"Total number of times replicated files and folders have been staged by the DFS Replication service",
 		[]string{"name"},
 		nil,
 	)
 
 	c.folderUpdatesDroppedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "folder_dropped_updates_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "folder_dropped_updates_total"),
 		"Total number of redundant file replication update records that have been ignored by the DFS Replication service because they did not change the replicated file or folder",
 		[]string{"name"},
 		nil,
@@ -504,35 +504,35 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 	// volume
 	c.volumeDatabaseCommitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "volume_database_commits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "volume_database_commits_total"),
 		"Total number of DFSR volume database commits",
 		[]string{"name"},
 		nil,
 	)
 
 	c.volumeDatabaseLookupsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "volume_database_lookups_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "volume_database_lookups_total"),
 		"Total number of DFSR volume database lookups",
 		[]string{"name"},
 		nil,
 	)
 
 	c.volumeUSNJournalUnreadPercentage = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "volume_usn_journal_unread_percentage"),
+		prometheus.BuildFQName(types.Namespace, Name, "volume_usn_journal_unread_percentage"),
 		"Percentage of DFSR volume USN journal records that are unread",
 		[]string{"name"},
 		nil,
 	)
 
 	c.volumeUSNJournalRecordsAcceptedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "volume_usn_journal_accepted_records_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "volume_usn_journal_accepted_records_total"),
 		"Total number of USN journal records accepted",
 		[]string{"name"},
 		nil,
 	)
 
 	c.volumeUSNJournalRecordsReadTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "volume_usn_journal_read_records_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "volume_usn_journal_read_records_total"),
 		"Total number of DFSR volume USN journal records read",
 		[]string{"name"},
 		nil,
@@ -566,7 +566,7 @@ func (c *Collector) getDFSRChildCollectors(enabledCollectors []string) []dfsrCol
 
 // Collect implements the Collector interface.
 // Sends metric values for each metric to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	if utils.PDHEnabled() {
 		return c.collectPDH(ch)
 	}
@@ -582,7 +582,7 @@ func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch c
 	return nil
 }
 
-func (c *Collector) collectConnection(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectConnection(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	var dst []PerflibDFSRConnection
 
 	if err := perflib.UnmarshalObject(ctx.PerfObjects["DFS Replication Connections"], &dst, logger); err != nil {
@@ -657,7 +657,7 @@ func (c *Collector) collectConnection(ctx *types2.ScrapeContext, logger *slog.Lo
 	return nil
 }
 
-func (c *Collector) collectFolder(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectFolder(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	var dst []perflibDFSRFolder
 
 	if err := perflib.UnmarshalObject(ctx.PerfObjects["DFS Replicated Folders"], &dst, logger); err != nil {
@@ -858,7 +858,7 @@ func (c *Collector) collectFolder(ctx *types2.ScrapeContext, logger *slog.Logger
 	return nil
 }
 
-func (c *Collector) collectVolume(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectVolume(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	var dst []perflibDFSRVolume
 
 	if err := perflib.UnmarshalObject(ctx.PerfObjects["DFS Replication Service Volumes"], &dst, logger); err != nil {

internal/collector/dhcp/dhcp.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -79,151 +79,151 @@ func (c *Collector) Close(_ *slog.Logger) error {
 
 func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	c.packetsReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "packets_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "packets_received_total"),
 		"Total number of packets received by the DHCP server (PacketsReceivedTotal)",
 		nil,
 		nil,
 	)
 	c.duplicatesDroppedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "duplicates_dropped_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "duplicates_dropped_total"),
 		"Total number of duplicate packets received by the DHCP server (DuplicatesDroppedTotal)",
 		nil,
 		nil,
 	)
 	c.packetsExpiredTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "packets_expired_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "packets_expired_total"),
 		"Total number of packets expired in the DHCP server message queue (PacketsExpiredTotal)",
 		nil,
 		nil,
 	)
 	c.activeQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "active_queue_length"),
+		prometheus.BuildFQName(types.Namespace, Name, "active_queue_length"),
 		"Number of packets in the processing queue of the DHCP server (ActiveQueueLength)",
 		nil,
 		nil,
 	)
 	c.conflictCheckQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "conflict_check_queue_length"),
+		prometheus.BuildFQName(types.Namespace, Name, "conflict_check_queue_length"),
 		"Number of packets in the DHCP server queue waiting on conflict detection (ping). (ConflictCheckQueueLength)",
 		nil,
 		nil,
 	)
 	c.discoversTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "discovers_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "discovers_total"),
 		"Total DHCP Discovers received by the DHCP server (DiscoversTotal)",
 		nil,
 		nil,
 	)
 	c.offersTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "offers_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "offers_total"),
 		"Total DHCP Offers sent by the DHCP server (OffersTotal)",
 		nil,
 		nil,
 	)
 	c.requestsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "requests_total"),
 		"Total DHCP Requests received by the DHCP server (RequestsTotal)",
 		nil,
 		nil,
 	)
 	c.informsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "informs_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "informs_total"),
 		"Total DHCP Informs received by the DHCP server (InformsTotal)",
 		nil,
 		nil,
 	)
 	c.acksTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "acks_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "acks_total"),
 		"Total DHCP Acks sent by the DHCP server (AcksTotal)",
 		nil,
 		nil,
 	)
 	c.nACKsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "nacks_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "nacks_total"),
 		"Total DHCP Nacks sent by the DHCP server (NacksTotal)",
 		nil,
 		nil,
 	)
 	c.declinesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "declines_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "declines_total"),
 		"Total DHCP Declines received by the DHCP server (DeclinesTotal)",
 		nil,
 		nil,
 	)
 	c.releasesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "releases_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "releases_total"),
 		"Total DHCP Releases received by the DHCP server (ReleasesTotal)",
 		nil,
 		nil,
 	)
 	c.offerQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "offer_queue_length"),
+		prometheus.BuildFQName(types.Namespace, Name, "offer_queue_length"),
 		"Number of packets in the offer queue of the DHCP server (OfferQueueLength)",
 		nil,
 		nil,
 	)
 	c.deniedDueToMatch = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "denied_due_to_match_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "denied_due_to_match_total"),
 		"Total number of DHCP requests denied, based on matches from the Deny list (DeniedDueToMatch)",
 		nil,
 		nil,
 	)
 	c.deniedDueToNonMatch = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "denied_due_to_nonmatch_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "denied_due_to_nonmatch_total"),
 		"Total number of DHCP requests denied, based on non-matches from the Allow list (DeniedDueToNonMatch)",
 		nil,
 		nil,
 	)
 	c.failoverBndupdSentTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "failover_bndupd_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "failover_bndupd_sent_total"),
 		"Number of DHCP fail over Binding Update messages sent (FailoverBndupdSentTotal)",
 		nil,
 		nil,
 	)
 	c.failoverBndupdReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "failover_bndupd_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "failover_bndupd_received_total"),
 		"Number of DHCP fail over Binding Update messages received (FailoverBndupdReceivedTotal)",
 		nil,
 		nil,
 	)
 	c.failoverBndackSentTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "failover_bndack_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "failover_bndack_sent_total"),
 		"Number of DHCP fail over Binding Ack messages sent (FailoverBndackSentTotal)",
 		nil,
 		nil,
 	)
 	c.failoverBndackReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "failover_bndack_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "failover_bndack_received_total"),
 		"Number of DHCP fail over Binding Ack messages received (FailoverBndackReceivedTotal)",
 		nil,
 		nil,
 	)
 	c.failoverBndupdPendingOutboundQueue = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "failover_bndupd_pending_in_outbound_queue"),
+		prometheus.BuildFQName(types.Namespace, Name, "failover_bndupd_pending_in_outbound_queue"),
 		"Number of pending outbound DHCP fail over Binding Update messages (FailoverBndupdPendingOutboundQueue)",
 		nil,
 		nil,
 	)
 	c.failoverTransitionsCommunicationInterruptedState = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "failover_transitions_communicationinterrupted_state_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "failover_transitions_communicationinterrupted_state_total"),
 		"Total number of transitions into COMMUNICATION INTERRUPTED state (FailoverTransitionsCommunicationinterruptedState)",
 		nil,
 		nil,
 	)
 	c.failoverTransitionsPartnerDownState = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "failover_transitions_partnerdown_state_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "failover_transitions_partnerdown_state_total"),
 		"Total number of transitions into PARTNER DOWN state (FailoverTransitionsPartnerdownState)",
 		nil,
 		nil,
 	)
 	c.failoverTransitionsRecoverState = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "failover_transitions_recover_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "failover_transitions_recover_total"),
 		"Total number of transitions into RECOVER state (FailoverTransitionsRecoverState)",
 		nil,
 		nil,
 	)
 	c.failoverBndupdDropped = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "failover_bndupd_dropped_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "failover_bndupd_dropped_total"),
 		"Total number of DHCP fail over Binding Updates dropped (FailoverBndupdDropped)",
 		nil,
 		nil,
@@ -263,7 +263,7 @@ type dhcpPerf struct {
 	FailoverBndupdDropped                            float64 `perflib:"Failover: BndUpd Dropped."`
 }
 
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var dhcpPerfs []dhcpPerf

internal/collector/diskdrive/diskdrive.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -69,7 +69,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 	c.wmiClient = wmiClient
 	c.diskInfo = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "info"),
+		prometheus.BuildFQName(types.Namespace, Name, "info"),
 		"General drive information",
 		[]string{
 			"device_id",
@@ -80,25 +80,25 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 		nil,
 	)
 	c.status = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "status"),
+		prometheus.BuildFQName(types.Namespace, Name, "status"),
 		"Status of the drive",
 		[]string{"name", "status"},
 		nil,
 	)
 	c.size = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "size"),
+		prometheus.BuildFQName(types.Namespace, Name, "size"),
 		"Size of the disk drive. It is calculated by multiplying the total number of cylinders, tracks in each cylinder, sectors in each track, and bytes in each sector.",
 		[]string{"name"},
 		nil,
 	)
 	c.partitions = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "partitions"),
+		prometheus.BuildFQName(types.Namespace, Name, "partitions"),
 		"Number of partitions",
 		[]string{"name"},
 		nil,
 	)
 	c.availability = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "availability"),
+		prometheus.BuildFQName(types.Namespace, Name, "availability"),
 		"Availability Status",
 		[]string{"name", "availability"},
 		nil,
@@ -160,7 +160,7 @@ var (
 )
 
 // Collect sends the metric values for each metric to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ch); err != nil {
 		logger.Error("failed collecting disk_drive_info metrics",

internal/collector/dns/dns.go

@@ -7,7 +7,7 @@ import (
 	"log/slog"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -83,133 +83,133 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	c.wmiClient = wmiClient
 
 	c.zoneTransferRequestsReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "zone_transfer_requests_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "zone_transfer_requests_received_total"),
 		"Number of zone transfer requests (AXFR/IXFR) received by the master DNS server",
 		[]string{"qtype"},
 		nil,
 	)
 	c.zoneTransferRequestsSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "zone_transfer_requests_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "zone_transfer_requests_sent_total"),
 		"Number of zone transfer requests (AXFR/IXFR) sent by the secondary DNS server",
 		[]string{"qtype"},
 		nil,
 	)
 	c.zoneTransferResponsesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "zone_transfer_response_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "zone_transfer_response_received_total"),
 		"Number of zone transfer responses (AXFR/IXFR) received by the secondary DNS server",
 		[]string{"qtype"},
 		nil,
 	)
 	c.zoneTransferSuccessReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "zone_transfer_success_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "zone_transfer_success_received_total"),
 		"Number of successful zone transfers (AXFR/IXFR) received by the secondary DNS server",
 		[]string{"qtype", "protocol"},
 		nil,
 	)
 	c.zoneTransferSuccessSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "zone_transfer_success_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "zone_transfer_success_sent_total"),
 		"Number of successful zone transfers (AXFR/IXFR) of the master DNS server",
 		[]string{"qtype"},
 		nil,
 	)
 	c.zoneTransferFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "zone_transfer_failures_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "zone_transfer_failures_total"),
 		"Number of failed zone transfers of the master DNS server",
 		nil,
 		nil,
 	)
 	c.memoryUsedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "memory_used_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "memory_used_bytes"),
 		"Current memory used by DNS server",
 		[]string{"area"},
 		nil,
 	)
 	c.dynamicUpdatesQueued = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "dynamic_updates_queued"),
+		prometheus.BuildFQName(types.Namespace, Name, "dynamic_updates_queued"),
 		"Number of dynamic updates queued by the DNS server",
 		nil,
 		nil,
 	)
 	c.dynamicUpdatesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "dynamic_updates_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "dynamic_updates_received_total"),
 		"Number of secure update requests received by the DNS server",
 		[]string{"operation"},
 		nil,
 	)
 	c.dynamicUpdatesFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "dynamic_updates_failures_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "dynamic_updates_failures_total"),
 		"Number of dynamic updates which timed out or were rejected by the DNS server",
 		[]string{"reason"},
 		nil,
 	)
 	c.notifyReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "notify_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "notify_received_total"),
 		"Number of notifies received by the secondary DNS server",
 		nil,
 		nil,
 	)
 	c.notifySent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "notify_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "notify_sent_total"),
 		"Number of notifies sent by the master DNS server",
 		nil,
 		nil,
 	)
 	c.secureUpdateFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "secure_update_failures_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "secure_update_failures_total"),
 		"Number of secure updates that failed on the DNS server",
 		nil,
 		nil,
 	)
 	c.secureUpdateReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "secure_update_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "secure_update_received_total"),
 		"Number of secure update requests received by the DNS server",
 		nil,
 		nil,
 	)
 	c.queries = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "queries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "queries_total"),
 		"Number of queries received by DNS server",
 		[]string{"protocol"},
 		nil,
 	)
 	c.responses = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "responses_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "responses_total"),
 		"Number of responses sent by DNS server",
 		[]string{"protocol"},
 		nil,
 	)
 	c.recursiveQueries = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "recursive_queries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "recursive_queries_total"),
 		"Number of recursive queries received by DNS server",
 		nil,
 		nil,
 	)
 	c.recursiveQueryFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "recursive_query_failures_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "recursive_query_failures_total"),
 		"Number of recursive query failures",
 		nil,
 		nil,
 	)
 	c.recursiveQuerySendTimeouts = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "recursive_query_send_timeouts_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "recursive_query_send_timeouts_total"),
 		"Number of recursive query sending timeouts",
 		nil,
 		nil,
 	)
 	c.winsQueries = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "wins_queries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "wins_queries_total"),
 		"Number of WINS lookup requests received by the server",
 		[]string{"direction"},
 		nil,
 	)
 	c.winsResponses = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "wins_responses_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "wins_responses_total"),
 		"Number of WINS lookup responses sent by the server",
 		[]string{"direction"},
 		nil,
 	)
 	c.unmatchedResponsesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "unmatched_responses_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "unmatched_responses_total"),
 		"Number of response packets received by the DNS server that do not match any outstanding remote query",
 		nil,
 		nil,
@@ -220,7 +220,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ch); err != nil {
 		logger.Error("failed collecting dns metrics",

internal/collector/exchange/exchange.go

@@ -10,7 +10,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -181,7 +181,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	// desc creates a new prometheus description
 	desc := func(metricName string, description string, labels ...string) *prometheus.Desc {
 		return prometheus.NewDesc(
-			prometheus.BuildFQName(types2.Namespace, "exchange", metricName),
+			prometheus.BuildFQName(types.Namespace, "exchange", metricName),
 			description,
 			labels,
 			nil,
@@ -231,9 +231,9 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 }
 
 // Collect collects exchange metrics and sends them to prometheus.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
-	collectorFuncs := map[string]func(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error{
+	collectorFuncs := map[string]func(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error{
 		"ADAccessProcesses":   c.collectADAccessProcesses,
 		"TransportQueues":     c.collectTransportQueues,
 		"HttpProxy":           c.collectHTTPProxy,
@@ -270,7 +270,7 @@ type perflibADAccessProcesses struct {
 	LongRunningLDAPOperationsPerMin float64 `perflib:"Long Running LDAP Operations/min"`
 }
 
-func (c *Collector) collectADAccessProcesses(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectADAccessProcesses(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var data []perflibADAccessProcesses
@@ -333,7 +333,7 @@ type perflibAvailabilityService struct {
 	RequestsSec float64 `perflib:"Availability Requests (sec)"`
 }
 
-func (c *Collector) collectAvailabilityService(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectAvailabilityService(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var data []perflibAvailabilityService
@@ -365,7 +365,7 @@ type perflibHTTPProxy struct {
 	ProxyRequestsPerSec                float64 `perflib:"Proxy Requests/Sec"`
 }
 
-func (c *Collector) collectHTTPProxy(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectHTTPProxy(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var data []perflibHTTPProxy
@@ -423,7 +423,7 @@ type perflibOWA struct {
 	RequestsPerSec     float64 `perflib:"Requests/sec"`
 }
 
-func (c *Collector) collectOWA(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectOWA(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var data []perflibOWA
@@ -455,7 +455,7 @@ type perflibActiveSync struct {
 	SyncCommandsPerSec  float64 `perflib:"Sync Commands/sec"`
 }
 
-func (c *Collector) collectActiveSync(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectActiveSync(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var data []perflibActiveSync
@@ -495,7 +495,7 @@ type perflibRPCClientAccess struct {
 	UserCount           float64 `perflib:"User Count"`
 }
 
-func (c *Collector) collectRPC(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectRPC(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var data []perflibRPCClientAccess
@@ -554,7 +554,7 @@ type perflibTransportQueues struct {
 	PoisonQueueLength                       float64 `perflib:"Poison Queue Length"`
 }
 
-func (c *Collector) collectTransportQueues(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectTransportQueues(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var data []perflibTransportQueues
@@ -632,7 +632,7 @@ type perflibWorkloadManagementWorkloads struct {
 	IsActive       float64 `perflib:"Active"`
 }
 
-func (c *Collector) collectWorkloadManagementWorkloads(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectWorkloadManagementWorkloads(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var data []perflibWorkloadManagementWorkloads
@@ -686,7 +686,7 @@ type perflibAutodiscover struct {
 	RequestsPerSec float64 `perflib:"Requests/sec"`
 }
 
-func (c *Collector) collectAutoDiscover(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectAutoDiscover(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var data []perflibAutodiscover
@@ -711,7 +711,7 @@ type perflibMapiHttpEmsmdb struct {
 	ActiveUserCount float64 `perflib:"Active User Count"`
 }
 
-func (c *Collector) collectMapiHttpEmsmdb(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectMapiHttpEmsmdb(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var data []perflibMapiHttpEmsmdb

internal/collector/filetime/filetime.go

@@ -12,7 +12,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/bmatcuk/doublestar/v4"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -91,7 +91,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 	)
 
 	c.fileMTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mtime_timestamp_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "mtime_timestamp_seconds"),
 		"File modification time",
 		[]string{"file"},
 		nil,
@@ -111,7 +111,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	return c.collectGlob(logger, ch)

internal/collector/fsrmquota/fsrmquota.go

@@ -7,7 +7,7 @@ import (
 	"log/slog"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus-community/windows_exporter/internal/utils"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
@@ -71,55 +71,55 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	c.wmiClient = wmiClient
 
 	c.quotasCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "count"),
+		prometheus.BuildFQName(types.Namespace, Name, "count"),
 		"Number of Quotas",
 		nil,
 		nil,
 	)
 	c.peakUsage = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "peak_usage_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "peak_usage_bytes"),
 		"The highest amount of disk space usage charged to this quota. (PeakUsage)",
 		[]string{"path", "template"},
 		nil,
 	)
 	c.size = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "size_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "size_bytes"),
 		"The size of the quota. (Size)",
 		[]string{"path", "template"},
 		nil,
 	)
 	c.usage = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "usage_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "usage_bytes"),
 		"The current amount of disk space usage charged to this quota. (Usage)",
 		[]string{"path", "template"},
 		nil,
 	)
 	c.description = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "description"),
+		prometheus.BuildFQName(types.Namespace, Name, "description"),
 		"Description of the quota (Description)",
 		[]string{"path", "template", "description"},
 		nil,
 	)
 	c.disabled = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "disabled"),
+		prometheus.BuildFQName(types.Namespace, Name, "disabled"),
 		"If 1, the quota is disabled. The default value is 0. (Disabled)",
 		[]string{"path", "template"},
 		nil,
 	)
 	c.softLimit = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "softlimit"),
+		prometheus.BuildFQName(types.Namespace, Name, "softlimit"),
 		"If 1, the quota is a soft limit. If 0, the quota is a hard limit. The default value is 0. Optional (SoftLimit)",
 		[]string{"path", "template"},
 		nil,
 	)
 	c.template = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "template"),
+		prometheus.BuildFQName(types.Namespace, Name, "template"),
 		"Quota template name. (Template)",
 		[]string{"path", "template"},
 		nil,
 	)
 	c.matchesTemplate = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "matchestemplate"),
+		prometheus.BuildFQName(types.Namespace, Name, "matchestemplate"),
 		"If 1, the property values of this quota match those values of the template from which it was derived. (MatchesTemplate)",
 		[]string{"path", "template"},
 		nil,
@@ -130,7 +130,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ch); err != nil {
 		logger.Error("failed collecting fsrmquota metrics",

internal/collector/hyperv/hyperv.go

@@ -9,7 +9,7 @@ import (
 	"strings"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -178,13 +178,13 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	buildSubsystemName := func(component string) string { return "hyperv_" + component }
 
 	c.healthCritical = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("health"), "critical"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("health"), "critical"),
 		"This counter represents the number of virtual machines with critical health",
 		nil,
 		nil,
 	)
 	c.healthOk = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("health"), "ok"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("health"), "ok"),
 		"This counter represents the number of virtual machines with ok health",
 		nil,
 		nil,
@@ -193,19 +193,19 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	//
 
 	c.physicalPagesAllocated = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vid"), "physical_pages_allocated"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vid"), "physical_pages_allocated"),
 		"The number of physical pages allocated",
 		[]string{"vm"},
 		nil,
 	)
 	c.preferredNUMANodeIndex = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vid"), "preferred_numa_node_index"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vid"), "preferred_numa_node_index"),
 		"The preferred NUMA node index associated with this partition",
 		[]string{"vm"},
 		nil,
 	)
 	c.remotePhysicalPages = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vid"), "remote_physical_pages"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vid"), "remote_physical_pages"),
 		"The number of physical pages not allocated from the preferred NUMA node",
 		[]string{"vm"},
 		nil,
@@ -214,127 +214,127 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	//
 
 	c.addressSpaces = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "address_spaces"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "address_spaces"),
 		"The number of address spaces in the virtual TLB of the partition",
 		nil,
 		nil,
 	)
 	c.attachedDevices = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "attached_devices"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "attached_devices"),
 		"The number of devices attached to the partition",
 		nil,
 		nil,
 	)
 	c.depositedPages = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "deposited_pages"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "deposited_pages"),
 		"The number of pages deposited into the partition",
 		nil,
 		nil,
 	)
 	c.deviceDMAErrors = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "device_dma_errors"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "device_dma_errors"),
 		"An indicator of illegal DMA requests generated by all devices assigned to the partition",
 		nil,
 		nil,
 	)
 	c.deviceInterruptErrors = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "device_interrupt_errors"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "device_interrupt_errors"),
 		"An indicator of illegal interrupt requests generated by all devices assigned to the partition",
 		nil,
 		nil,
 	)
 	c.deviceInterruptMappings = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "device_interrupt_mappings"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "device_interrupt_mappings"),
 		"The number of device interrupt mappings used by the partition",
 		nil,
 		nil,
 	)
 	c.deviceInterruptThrottleEvents = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "device_interrupt_throttle_events"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "device_interrupt_throttle_events"),
 		"The number of times an interrupt from a device assigned to the partition was temporarily throttled because the device was generating too many interrupts",
 		nil,
 		nil,
 	)
 	c.gpaPages = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "preferred_numa_node_index"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "preferred_numa_node_index"),
 		"The number of pages present in the GPA space of the partition (zero for root partition)",
 		nil,
 		nil,
 	)
 	c.gpaSpaceModifications = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "gpa_space_modifications"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "gpa_space_modifications"),
 		"The rate of modifications to the GPA space of the partition",
 		nil,
 		nil,
 	)
 	c.ioTLBFlushCost = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "io_tlb_flush_cost"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "io_tlb_flush_cost"),
 		"The average time (in nanoseconds) spent processing an I/O TLB flush",
 		nil,
 		nil,
 	)
 	c.ioTLBFlushes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "io_tlb_flush"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "io_tlb_flush"),
 		"The rate of flushes of I/O TLBs of the partition",
 		nil,
 		nil,
 	)
 	c.recommendedVirtualTLBSize = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "recommended_virtual_tlb_size"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "recommended_virtual_tlb_size"),
 		"The recommended number of pages to be deposited for the virtual TLB",
 		nil,
 		nil,
 	)
 	c.skippedTimerTicks = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "physical_pages_allocated"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "physical_pages_allocated"),
 		"The number of timer interrupts skipped for the partition",
 		nil,
 		nil,
 	)
 	c.value1Gdevicepages = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "1G_device_pages"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "1G_device_pages"),
 		"The number of 1G pages present in the device space of the partition",
 		nil,
 		nil,
 	)
 	c.value1GGPApages = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "1G_gpa_pages"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "1G_gpa_pages"),
 		"The number of 1G pages present in the GPA space of the partition",
 		nil,
 		nil,
 	)
 	c.value2Mdevicepages = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "2M_device_pages"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "2M_device_pages"),
 		"The number of 2M pages present in the device space of the partition",
 		nil,
 		nil,
 	)
 	c.value2MGPApages = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "2M_gpa_pages"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "2M_gpa_pages"),
 		"The number of 2M pages present in the GPA space of the partition",
 		nil,
 		nil,
 	)
 	c.value4Kdevicepages = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "4K_device_pages"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "4K_device_pages"),
 		"The number of 4K pages present in the device space of the partition",
 		nil,
 		nil,
 	)
 	c.value4KGPApages = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "4K_gpa_pages"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "4K_gpa_pages"),
 		"The number of 4K pages present in the GPA space of the partition",
 		nil,
 		nil,
 	)
 	c.virtualTLBFlushEntires = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "virtual_tlb_flush_entires"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "virtual_tlb_flush_entires"),
 		"The rate of flushes of the entire virtual TLB",
 		nil,
 		nil,
 	)
 	c.virtualTLBPages = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("root_partition"), "virtual_tlb_pages"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("root_partition"), "virtual_tlb_pages"),
 		"The number of pages used by the virtual TLB of the partition",
 		nil,
 		nil,
@@ -343,13 +343,13 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	//
 
 	c.virtualProcessors = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("hypervisor"), "virtual_processors"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("hypervisor"), "virtual_processors"),
 		"The number of virtual processors present in the system",
 		nil,
 		nil,
 	)
 	c.logicalProcessors = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("hypervisor"), "logical_processors"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("hypervisor"), "logical_processors"),
 		"The number of logical processors present in the system",
 		nil,
 		nil,
@@ -358,19 +358,19 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	//
 
 	c.hostLPGuestRunTimePercent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("host_lp"), "guest_run_time_percent"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("host_lp"), "guest_run_time_percent"),
 		"The percentage of time spent by the processor in guest code",
 		[]string{"core"},
 		nil,
 	)
 	c.hostLPHypervisorRunTimePercent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("host_lp"), "hypervisor_run_time_percent"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("host_lp"), "hypervisor_run_time_percent"),
 		"The percentage of time spent by the processor in hypervisor code",
 		[]string{"core"},
 		nil,
 	)
 	c.hostLPTotalRunTimePercent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("host_lp"), "total_run_time_percent"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("host_lp"), "total_run_time_percent"),
 		"The percentage of time spent by the processor in guest and hypervisor code",
 		[]string{"core"},
 		nil,
@@ -379,31 +379,31 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	//
 
 	c.hostGuestRunTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("host_cpu"), "guest_run_time"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("host_cpu"), "guest_run_time"),
 		"The time spent by the virtual processor in guest code",
 		[]string{"core"},
 		nil,
 	)
 	c.hostHypervisorRunTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("host_cpu"), "hypervisor_run_time"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("host_cpu"), "hypervisor_run_time"),
 		"The time spent by the virtual processor in hypervisor code",
 		[]string{"core"},
 		nil,
 	)
 	c.hostRemoteRunTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("host_cpu"), "remote_run_time"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("host_cpu"), "remote_run_time"),
 		"The time spent by the virtual processor running on a remote node",
 		[]string{"core"},
 		nil,
 	)
 	c.hostTotalRunTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("host_cpu"), "total_run_time"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("host_cpu"), "total_run_time"),
 		"The time spent by the virtual processor in guest and hypervisor code",
 		[]string{"core"},
 		nil,
 	)
 	c.hostCPUWaitTimePerDispatch = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("host_cpu"), "wait_time_per_dispatch_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("host_cpu"), "wait_time_per_dispatch_total"),
 		"Time in nanoseconds waiting for a virtual processor to be dispatched onto a logical processor",
 		[]string{"core"},
 		nil,
@@ -412,31 +412,31 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	//
 
 	c.vmGuestRunTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_cpu"), "guest_run_time"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_cpu"), "guest_run_time"),
 		"The time spent by the virtual processor in guest code",
 		[]string{"vm", "core"},
 		nil,
 	)
 	c.vmHypervisorRunTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_cpu"), "hypervisor_run_time"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_cpu"), "hypervisor_run_time"),
 		"The time spent by the virtual processor in hypervisor code",
 		[]string{"vm", "core"},
 		nil,
 	)
 	c.vmRemoteRunTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_cpu"), "remote_run_time"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_cpu"), "remote_run_time"),
 		"The time spent by the virtual processor running on a remote node",
 		[]string{"vm", "core"},
 		nil,
 	)
 	c.vmTotalRunTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_cpu"), "total_run_time"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_cpu"), "total_run_time"),
 		"The time spent by the virtual processor in guest and hypervisor code",
 		[]string{"vm", "core"},
 		nil,
 	)
 	c.vmCPUWaitTimePerDispatch = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_cpu"), "wait_time_per_dispatch_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_cpu"), "wait_time_per_dispatch_total"),
 		"Time in nanoseconds waiting for a virtual processor to be dispatched onto a logical processor",
 		[]string{"vm", "core"},
 		nil,
@@ -444,127 +444,127 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 	//
 	c.broadcastPacketsReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "broadcast_packets_received_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "broadcast_packets_received_total"),
 		"This represents the total number of broadcast packets received per second by the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.broadcastPacketsSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "broadcast_packets_sent_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "broadcast_packets_sent_total"),
 		"This represents the total number of broadcast packets sent per second by the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.bytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "bytes_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "bytes_total"),
 		"This represents the total number of bytes per second traversing the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.bytesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "bytes_received_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "bytes_received_total"),
 		"This represents the total number of bytes received per second by the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.bytesSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "bytes_sent_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "bytes_sent_total"),
 		"This represents the total number of bytes sent per second by the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.directedPacketsReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "directed_packets_received_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "directed_packets_received_total"),
 		"This represents the total number of directed packets received per second by the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.directedPacketsSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "directed_packets_send_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "directed_packets_send_total"),
 		"This represents the total number of directed packets sent per second by the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.droppedPacketsIncoming = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "dropped_packets_incoming_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "dropped_packets_incoming_total"),
 		"This represents the total number of packet dropped per second by the virtual switch in the incoming direction",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.droppedPacketsOutgoing = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "dropped_packets_outcoming_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "dropped_packets_outcoming_total"),
 		"This represents the total number of packet dropped per second by the virtual switch in the outgoing direction",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.extensionsDroppedPacketsIncoming = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "extensions_dropped_packets_incoming_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "extensions_dropped_packets_incoming_total"),
 		"This represents the total number of packet dropped per second by the virtual switch extensions in the incoming direction",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.extensionsDroppedPacketsOutgoing = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "extensions_dropped_packets_outcoming_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "extensions_dropped_packets_outcoming_total"),
 		"This represents the total number of packet dropped per second by the virtual switch extensions in the outgoing direction",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.learnedMacAddresses = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "learned_mac_addresses_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "learned_mac_addresses_total"),
 		"This counter represents the total number of learned MAC addresses of the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.multicastPacketsReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "multicast_packets_received_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "multicast_packets_received_total"),
 		"This represents the total number of multicast packets received per second by the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.multicastPacketsSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "multicast_packets_sent_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "multicast_packets_sent_total"),
 		"This represents the total number of multicast packets sent per second by the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.numberOfSendChannelMoves = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "number_of_send_channel_moves_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "number_of_send_channel_moves_total"),
 		"This represents the total number of send channel moves per second on this virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.numberOfVMQMoves = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "number_of_vmq_moves_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "number_of_vmq_moves_total"),
 		"This represents the total number of VMQ moves per second on this virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.packetsFlooded = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "packets_flooded_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "packets_flooded_total"),
 		"This counter represents the total number of packets flooded by the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.packets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "packets_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "packets_total"),
 		"This represents the total number of packets per second traversing the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.packetsReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "packets_received_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "packets_received_total"),
 		"This represents the total number of packets received per second by the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.packetsSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "packets_sent_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "packets_sent_total"),
 		"This represents the total number of packets send per second by the virtual switch",
 		[]string{"vswitch"},
 		nil,
 	)
 	c.purgedMacAddresses = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vswitch"), "purged_mac_addresses_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vswitch"), "purged_mac_addresses_total"),
 		"This counter represents the total number of purged MAC addresses of the virtual switch",
 		[]string{"vswitch"},
 		nil,
@@ -573,37 +573,37 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	//
 
 	c.adapterBytesDropped = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("ethernet"), "bytes_dropped"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("ethernet"), "bytes_dropped"),
 		"Bytes Dropped is the number of bytes dropped on the network adapter",
 		[]string{"adapter"},
 		nil,
 	)
 	c.adapterBytesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("ethernet"), "bytes_received"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("ethernet"), "bytes_received"),
 		"Bytes received is the number of bytes received on the network adapter",
 		[]string{"adapter"},
 		nil,
 	)
 	c.adapterBytesSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("ethernet"), "bytes_sent"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("ethernet"), "bytes_sent"),
 		"Bytes sent is the number of bytes sent over the network adapter",
 		[]string{"adapter"},
 		nil,
 	)
 	c.adapterFramesDropped = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("ethernet"), "frames_dropped"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("ethernet"), "frames_dropped"),
 		"Frames Dropped is the number of frames dropped on the network adapter",
 		[]string{"adapter"},
 		nil,
 	)
 	c.adapterFramesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("ethernet"), "frames_received"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("ethernet"), "frames_received"),
 		"Frames received is the number of frames received on the network adapter",
 		[]string{"adapter"},
 		nil,
 	)
 	c.adapterFramesSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("ethernet"), "frames_sent"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("ethernet"), "frames_sent"),
 		"Frames sent is the number of frames sent over the network adapter",
 		[]string{"adapter"},
 		nil,
@@ -612,37 +612,37 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	//
 
 	c.vmStorageErrorCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_device"), "error_count"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_device"), "error_count"),
 		"This counter represents the total number of errors that have occurred on this virtual device",
 		[]string{"vm_device"},
 		nil,
 	)
 	c.vmStorageQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_device"), "queue_length"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_device"), "queue_length"),
 		"This counter represents the current queue length on this virtual device",
 		[]string{"vm_device"},
 		nil,
 	)
 	c.vmStorageReadBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_device"), "bytes_read"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_device"), "bytes_read"),
 		"This counter represents the total number of bytes that have been read per second on this virtual device",
 		[]string{"vm_device"},
 		nil,
 	)
 	c.vmStorageReadOperations = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_device"), "operations_read"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_device"), "operations_read"),
 		"This counter represents the number of read operations that have occurred per second on this virtual device",
 		[]string{"vm_device"},
 		nil,
 	)
 	c.vmStorageWriteBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_device"), "bytes_written"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_device"), "bytes_written"),
 		"This counter represents the total number of bytes that have been written per second on this virtual device",
 		[]string{"vm_device"},
 		nil,
 	)
 	c.vmStorageWriteOperations = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_device"), "operations_written"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_device"), "operations_written"),
 		"This counter represents the number of write operations that have occurred per second on this virtual device",
 		[]string{"vm_device"},
 		nil,
@@ -651,37 +651,37 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	//
 
 	c.vmStorageBytesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_interface"), "bytes_received"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_interface"), "bytes_received"),
 		"This counter represents the total number of bytes received per second by the network adapter",
 		[]string{"vm_interface"},
 		nil,
 	)
 	c.vmStorageBytesSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_interface"), "bytes_sent"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_interface"), "bytes_sent"),
 		"This counter represents the total number of bytes sent per second by the network adapter",
 		[]string{"vm_interface"},
 		nil,
 	)
 	c.vmStorageDroppedPacketsIncoming = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_interface"), "packets_incoming_dropped"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_interface"), "packets_incoming_dropped"),
 		"This counter represents the total number of dropped packets per second in the incoming direction of the network adapter",
 		[]string{"vm_interface"},
 		nil,
 	)
 	c.vmStorageDroppedPacketsOutgoing = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_interface"), "packets_outgoing_dropped"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_interface"), "packets_outgoing_dropped"),
 		"This counter represents the total number of dropped packets per second in the outgoing direction of the network adapter",
 		[]string{"vm_interface"},
 		nil,
 	)
 	c.vmStoragePacketsReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_interface"), "packets_received"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_interface"), "packets_received"),
 		"This counter represents the total number of packets received per second by the network adapter",
 		[]string{"vm_interface"},
 		nil,
 	)
 	c.vmStoragePacketsSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_interface"), "packets_sent"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_interface"), "packets_sent"),
 		"This counter represents the total number of packets sent per second by the network adapter",
 		[]string{"vm_interface"},
 		nil,
@@ -690,61 +690,61 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	//
 
 	c.vmMemoryAddedMemory = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_memory"), "added_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_memory"), "added_total"),
 		"This counter represents memory in MB added to the VM",
 		[]string{"vm"},
 		nil,
 	)
 	c.vmMemoryAveragePressure = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_memory"), "pressure_average"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_memory"), "pressure_average"),
 		"This gauge represents the average pressure in the VM.",
 		[]string{"vm"},
 		nil,
 	)
 	c.vmMemoryCurrentPressure = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_memory"), "pressure_current"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_memory"), "pressure_current"),
 		"This gauge represents the current pressure in the VM.",
 		[]string{"vm"},
 		nil,
 	)
 	c.vmMemoryGuestVisiblePhysicalMemory = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_memory"), "physical_guest_visible"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_memory"), "physical_guest_visible"),
 		"'This gauge represents the amount of memory in MB visible to the VM guest.'",
 		[]string{"vm"},
 		nil,
 	)
 	c.vmMemoryMaximumPressure = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_memory"), "pressure_maximum"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_memory"), "pressure_maximum"),
 		"This gauge represents the maximum pressure band in the VM.",
 		[]string{"vm"},
 		nil,
 	)
 	c.vmMemoryMemoryAddOperations = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_memory"), "add_operations_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_memory"), "add_operations_total"),
 		"This counter represents the number of operations adding memory to the VM.",
 		[]string{"vm"},
 		nil,
 	)
 	c.vmMemoryMemoryRemoveOperations = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_memory"), "remove_operations_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_memory"), "remove_operations_total"),
 		"This counter represents the number of operations removing memory from the VM.",
 		[]string{"vm"},
 		nil,
 	)
 	c.vmMemoryMinimumPressure = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_memory"), "pressure_minimum"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_memory"), "pressure_minimum"),
 		"This gauge represents the minimum pressure band in the VM.",
 		[]string{"vm"},
 		nil,
 	)
 	c.vmMemoryPhysicalMemory = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_memory"), "physical"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_memory"), "physical"),
 		"This gauge represents the current amount of memory in MB assigned to the VM.",
 		[]string{"vm"},
 		nil,
 	)
 	c.vmMemoryRemovedMemory = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, buildSubsystemName("vm_memory"), "removed_total"),
+		prometheus.BuildFQName(types.Namespace, buildSubsystemName("vm_memory"), "removed_total"),
 		"This counter represents memory in MB removed from the VM",
 		[]string{"vm"},
 		nil,
@@ -755,7 +755,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collectVmHealth(ch); err != nil {
 		logger.Error("failed collecting hyperV health status metrics",

internal/collector/iis/iis.go

@@ -11,7 +11,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 	"golang.org/x/sys/windows/registry"
@@ -27,10 +27,10 @@ type Config struct {
 }
 
 var ConfigDefaults = Config{
-	SiteInclude: types2.RegExpAny,
+	SiteInclude: types.RegExpAny,
-	SiteExclude: types2.RegExpEmpty,
+	SiteExclude: types.RegExpEmpty,
-	AppInclude:  types2.RegExpAny,
+	AppInclude:  types.RegExpAny,
-	AppExclude:  types2.RegExpEmpty,
+	AppExclude:  types.RegExpEmpty,
 }
 
 type Collector struct {
@@ -268,7 +268,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 	c.iisVersion = getIISVersion(logger)
 
 	c.info = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "info"),
+		prometheus.BuildFQName(types.Namespace, Name, "info"),
 		"ISS information",
 		[]string{},
 		prometheus.Labels{
@@ -278,133 +278,133 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 	// Web Service
 	c.currentAnonymousUsers = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "current_anonymous_users"),
+		prometheus.BuildFQName(types.Namespace, Name, "current_anonymous_users"),
 		"Number of users who currently have an anonymous connection using the Web service (WebService.CurrentAnonymousUsers)",
 		[]string{"site"},
 		nil,
 	)
 	c.currentBlockedAsyncIORequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "current_blocked_async_io_requests"),
+		prometheus.BuildFQName(types.Namespace, Name, "current_blocked_async_io_requests"),
 		"Current requests temporarily blocked due to bandwidth throttling settings (WebService.CurrentBlockedAsyncIORequests)",
 		[]string{"site"},
 		nil,
 	)
 	c.currentCGIRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "current_cgi_requests"),
+		prometheus.BuildFQName(types.Namespace, Name, "current_cgi_requests"),
 		"Current number of CGI requests being simultaneously processed by the Web service (WebService.CurrentCGIRequests)",
 		[]string{"site"},
 		nil,
 	)
 	c.currentConnections = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "current_connections"),
+		prometheus.BuildFQName(types.Namespace, Name, "current_connections"),
 		"Current number of connections established with the Web service (WebService.CurrentConnections)",
 		[]string{"site"},
 		nil,
 	)
 	c.currentISAPIExtensionRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "current_isapi_extension_requests"),
+		prometheus.BuildFQName(types.Namespace, Name, "current_isapi_extension_requests"),
 		"Current number of ISAPI requests being simultaneously processed by the Web service (WebService.CurrentISAPIExtensionRequests)",
 		[]string{"site"},
 		nil,
 	)
 	c.currentNonAnonymousUsers = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "current_non_anonymous_users"),
+		prometheus.BuildFQName(types.Namespace, Name, "current_non_anonymous_users"),
 		"Number of users who currently have a non-anonymous connection using the Web service (WebService.CurrentNonAnonymousUsers)",
 		[]string{"site"},
 		nil,
 	)
 	c.serviceUptime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "service_uptime"),
+		prometheus.BuildFQName(types.Namespace, Name, "service_uptime"),
 		"Number of seconds the WebService is up (WebService.ServiceUptime)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalBytesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "received_bytes_total"),
 		"Number of data bytes that have been received by the Web service (WebService.TotalBytesReceived)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalBytesSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "sent_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "sent_bytes_total"),
 		"Number of data bytes that have been sent by the Web service (WebService.TotalBytesSent)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalAnonymousUsers = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "anonymous_users_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "anonymous_users_total"),
 		"Total number of users who established an anonymous connection with the Web service (WebService.TotalAnonymousUsers)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalBlockedAsyncIORequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "blocked_async_io_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "blocked_async_io_requests_total"),
 		"Total requests temporarily blocked due to bandwidth throttling settings (WebService.TotalBlockedAsyncIORequests)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalCGIRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cgi_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cgi_requests_total"),
 		"Total CGI requests is the total number of CGI requests (WebService.TotalCGIRequests)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalConnectionAttemptsAllInstances = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_attempts_all_instances_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_attempts_all_instances_total"),
 		"Number of connections that have been attempted using the Web service (WebService.TotalConnectionAttemptsAllInstances)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "requests_total"),
 		"Number of HTTP requests (WebService.TotalRequests)",
 		[]string{"site", "method"},
 		nil,
 	)
 	c.totalFilesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "files_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "files_received_total"),
 		"Number of files received by the Web service (WebService.TotalFilesReceived)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalFilesSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "files_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "files_sent_total"),
 		"Number of files sent by the Web service (WebService.TotalFilesSent)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalISAPIExtensionRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ipapi_extension_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "ipapi_extension_requests_total"),
 		"ISAPI Extension Requests received (WebService.TotalISAPIExtensionRequests)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalLockedErrors = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "locked_errors_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "locked_errors_total"),
 		"Number of requests that couldn't be satisfied by the server because the requested resource was locked (WebService.TotalLockedErrors)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalLogonAttempts = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "logon_attempts_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "logon_attempts_total"),
 		"Number of logons attempts to the Web Service (WebService.TotalLogonAttempts)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalNonAnonymousUsers = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "non_anonymous_users_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "non_anonymous_users_total"),
 		"Number of users who established a non-anonymous connection with the Web service (WebService.TotalNonAnonymousUsers)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalNotFoundErrors = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "not_found_errors_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "not_found_errors_total"),
 		"Number of requests that couldn't be satisfied by the server because the requested document could not be found (WebService.TotalNotFoundErrors)",
 		[]string{"site"},
 		nil,
 	)
 	c.totalRejectedAsyncIORequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "rejected_async_io_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "rejected_async_io_requests_total"),
 		"Requests rejected due to bandwidth throttling settings (WebService.TotalRejectedAsyncIORequests)",
 		[]string{"site"},
 		nil,
@@ -412,79 +412,79 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 	// APP_POOL_WAS
 	c.currentApplicationPoolState = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "current_application_pool_state"),
+		prometheus.BuildFQName(types.Namespace, Name, "current_application_pool_state"),
 		"The current status of the application pool (1 - Uninitialized, 2 - Initialized, 3 - Running, 4 - Disabling, 5 - Disabled, 6 - Shutdown Pending, 7 - Delete Pending) (CurrentApplicationPoolState)",
 		[]string{"app", "state"},
 		nil,
 	)
 	c.currentApplicationPoolUptime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "current_application_pool_start_time"),
+		prometheus.BuildFQName(types.Namespace, Name, "current_application_pool_start_time"),
 		"The unix timestamp for the application pool start time (CurrentApplicationPoolUptime)",
 		[]string{"app"},
 		nil,
 	)
 	c.currentWorkerProcesses = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "current_worker_processes"),
+		prometheus.BuildFQName(types.Namespace, Name, "current_worker_processes"),
 		"The current number of worker processes that are running in the application pool (CurrentWorkerProcesses)",
 		[]string{"app"},
 		nil,
 	)
 	c.maximumWorkerProcesses = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "maximum_worker_processes"),
+		prometheus.BuildFQName(types.Namespace, Name, "maximum_worker_processes"),
 		"The maximum number of worker processes that have been created for the application pool since Windows Process Activation Service (WAS) started (MaximumWorkerProcesses)",
 		[]string{"app"},
 		nil,
 	)
 	c.recentWorkerProcessFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "recent_worker_process_failures"),
+		prometheus.BuildFQName(types.Namespace, Name, "recent_worker_process_failures"),
 		"The number of times that worker processes for the application pool failed during the rapid-fail protection interval (RecentWorkerProcessFailures)",
 		[]string{"app"},
 		nil,
 	)
 	c.timeSinceLastWorkerProcessFailure = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "time_since_last_worker_process_failure"),
+		prometheus.BuildFQName(types.Namespace, Name, "time_since_last_worker_process_failure"),
 		"The length of time, in seconds, since the last worker process failure occurred for the application pool (TimeSinceLastWorkerProcessFailure)",
 		[]string{"app"},
 		nil,
 	)
 	c.totalApplicationPoolRecycles = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "total_application_pool_recycles"),
+		prometheus.BuildFQName(types.Namespace, Name, "total_application_pool_recycles"),
 		"The number of times that the application pool has been recycled since Windows Process Activation Service (WAS) started (TotalApplicationPoolRecycles)",
 		[]string{"app"},
 		nil,
 	)
 	c.totalApplicationPoolUptime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "total_application_pool_start_time"),
+		prometheus.BuildFQName(types.Namespace, Name, "total_application_pool_start_time"),
 		"The unix timestamp for the application pool of when the Windows Process Activation Service (WAS) started (TotalApplicationPoolUptime)",
 		[]string{"app"},
 		nil,
 	)
 	c.totalWorkerProcessesCreated = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "total_worker_processes_created"),
+		prometheus.BuildFQName(types.Namespace, Name, "total_worker_processes_created"),
 		"The number of worker processes created for the application pool since Windows Process Activation Service (WAS) started (TotalWorkerProcessesCreated)",
 		[]string{"app"},
 		nil,
 	)
 	c.totalWorkerProcessFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "total_worker_process_failures"),
+		prometheus.BuildFQName(types.Namespace, Name, "total_worker_process_failures"),
 		"The number of times that worker processes have crashed since the application pool was started (TotalWorkerProcessFailures)",
 		[]string{"app"},
 		nil,
 	)
 	c.totalWorkerProcessPingFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "total_worker_process_ping_failures"),
+		prometheus.BuildFQName(types.Namespace, Name, "total_worker_process_ping_failures"),
 		"The number of times that Windows Process Activation Service (WAS) did not receive a response to ping messages sent to a worker process (TotalWorkerProcessPingFailures)",
 		[]string{"app"},
 		nil,
 	)
 	c.totalWorkerProcessShutdownFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "total_worker_process_shutdown_failures"),
+		prometheus.BuildFQName(types.Namespace, Name, "total_worker_process_shutdown_failures"),
 		"The number of times that Windows Process Activation Service (WAS) failed to shut down a worker process (TotalWorkerProcessShutdownFailures)",
 		[]string{"app"},
 		nil,
 	)
 	c.totalWorkerProcessStartupFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "total_worker_process_startup_failures"),
+		prometheus.BuildFQName(types.Namespace, Name, "total_worker_process_startup_failures"),
 		"The number of times that Windows Process Activation Service (WAS) failed to start a worker process (TotalWorkerProcessStartupFailures)",
 		[]string{"app"},
 		nil,
@@ -492,224 +492,224 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 	// W3SVC_W3WP
 	c.threads = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_threads"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_threads"),
 		"Number of threads actively processing requests in the worker process",
 		[]string{"app", "pid", "state"},
 		nil,
 	)
 	c.maximumThreads = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_max_threads"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_max_threads"),
 		"Maximum number of threads to which the thread pool can grow as needed",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.requestsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_requests_total"),
 		"Total number of HTTP requests served by the worker process",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.requestsActive = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_current_requests"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_current_requests"),
 		"Current number of requests being processed by the worker process",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.activeFlushedEntries = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_cache_active_flushed_entries"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_cache_active_flushed_entries"),
 		"Number of file handles cached in user-mode that will be closed when all current transfers complete.",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.currentFileCacheMemoryUsage = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_file_cache_memory_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_file_cache_memory_bytes"),
 		"Current number of bytes used by user-mode file cache",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.maximumFileCacheMemoryUsage = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_file_cache_max_memory_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_file_cache_max_memory_bytes"),
 		"Maximum number of bytes used by user-mode file cache",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.fileCacheFlushesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_file_cache_flushes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_file_cache_flushes_total"),
 		"Total number of files removed from the user-mode cache",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.fileCacheQueriesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_file_cache_queries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_file_cache_queries_total"),
 		"Total file cache queries (hits + misses)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.fileCacheHitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_file_cache_hits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_file_cache_hits_total"),
 		"Total number of successful lookups in the user-mode file cache",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.filesCached = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_file_cache_items"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_file_cache_items"),
 		"Current number of files whose contents are present in user-mode cache",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.filesCachedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_file_cache_items_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_file_cache_items_total"),
 		"Total number of files whose contents were ever added to the user-mode cache (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.filesFlushedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_file_cache_items_flushed_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_file_cache_items_flushed_total"),
 		"Total number of file handles that have been removed from the user-mode cache (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.uriCacheFlushesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_uri_cache_flushes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_uri_cache_flushes_total"),
 		"Total number of URI cache flushes (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.uriCacheQueriesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_uri_cache_queries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_uri_cache_queries_total"),
 		"Total number of uri cache queries (hits + misses)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.uriCacheHitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_uri_cache_hits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_uri_cache_hits_total"),
 		"Total number of successful lookups in the user-mode URI cache (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.urisCached = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_uri_cache_items"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_uri_cache_items"),
 		"Number of URI information blocks currently in the user-mode cache",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.urisCachedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_uri_cache_items_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_uri_cache_items_total"),
 		"Total number of URI information blocks added to the user-mode cache (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.urisFlushedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_uri_cache_items_flushed_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_uri_cache_items_flushed_total"),
 		"The number of URI information blocks that have been removed from the user-mode cache (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.metadataCached = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_metadata_cache_items"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_metadata_cache_items"),
 		"Number of metadata information blocks currently present in user-mode cache",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.metadataCacheFlushes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_metadata_cache_flushes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_metadata_cache_flushes_total"),
 		"Total number of user-mode metadata cache flushes (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.metadataCacheQueriesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_metadata_cache_queries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_metadata_cache_queries_total"),
 		"Total metadata cache queries (hits + misses)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.metadataCacheHitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_metadata_cache_hits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_metadata_cache_hits_total"),
 		"Total number of successful lookups in the user-mode metadata cache (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.metadataCachedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_metadata_cache_items_cached_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_metadata_cache_items_cached_total"),
 		"Total number of metadata information blocks added to the user-mode cache (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.metadataFlushedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_metadata_cache_items_flushed_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_metadata_cache_items_flushed_total"),
 		"Total number of metadata information blocks removed from the user-mode cache (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.outputCacheActiveFlushedItems = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_output_cache_active_flushed_items"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_output_cache_active_flushed_items"),
 		"",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.outputCacheItems = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_output_cache_items"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_output_cache_items"),
 		"Number of items current present in output cache",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.outputCacheMemoryUsage = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_output_cache_memory_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_output_cache_memory_bytes"),
 		"Current number of bytes used by output cache",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.outputCacheQueriesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_output_queries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_output_queries_total"),
 		"Total number of output cache queries (hits + misses)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.outputCacheHitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_output_cache_hits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_output_cache_hits_total"),
 		"Total number of successful lookups in output cache (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.outputCacheFlushedItemsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_output_cache_items_flushed_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_output_cache_items_flushed_total"),
 		"Total number of items flushed from output cache (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.outputCacheFlushesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_output_cache_flushes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_output_cache_flushes_total"),
 		"Total number of flushes of output cache (since service startup)",
 		[]string{"app", "pid"},
 		nil,
 	)
 	// W3SVC_W3WP_IIS8
 	c.requestErrorsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_request_errors_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_request_errors_total"),
 		"Total number of requests that returned an error",
 		[]string{"app", "pid", "status_code"},
 		nil,
 	)
 	c.webSocketRequestsActive = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_current_websocket_requests"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_current_websocket_requests"),
 		"",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.webSocketConnectionAttempts = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_websocket_connection_attempts_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_websocket_connection_attempts_total"),
 		"",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.webSocketConnectionsAccepted = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_websocket_connection_accepted_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_websocket_connection_accepted_total"),
 		"",
 		[]string{"app", "pid"},
 		nil,
 	)
 	c.webSocketConnectionsRejected = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "worker_websocket_connection_rejected_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "worker_websocket_connection_rejected_total"),
 		"",
 		[]string{"app", "pid"},
 		nil,
@@ -717,169 +717,169 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 	// Web Service Cache
 	c.serviceCacheActiveFlushedEntries = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_cache_active_flushed_entries"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_cache_active_flushed_entries"),
 		"Number of file handles cached that will be closed when all current transfers complete.",
 		nil,
 		nil,
 	)
 	c.serviceCacheCurrentFileCacheMemoryUsage = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_file_cache_memory_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_file_cache_memory_bytes"),
 		"Current number of bytes used by file cache",
 		nil,
 		nil,
 	)
 	c.serviceCacheMaximumFileCacheMemoryUsage = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_file_cache_max_memory_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_file_cache_max_memory_bytes"),
 		"Maximum number of bytes used by file cache",
 		nil,
 		nil,
 	)
 	c.serviceCacheFileCacheFlushesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_file_cache_flushes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_file_cache_flushes_total"),
 		"Total number of file cache flushes (since service startup)",
 		nil,
 		nil,
 	)
 	c.serviceCacheFileCacheQueriesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_file_cache_queries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_file_cache_queries_total"),
 		"Total number of file cache queries (hits + misses)",
 		nil,
 		nil,
 	)
 	c.serviceCacheFileCacheHitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_file_cache_hits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_file_cache_hits_total"),
 		"Total number of successful lookups in the user-mode file cache",
 		nil,
 		nil,
 	)
 	c.serviceCacheFilesCached = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_file_cache_items"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_file_cache_items"),
 		"Current number of files whose contents are present in cache",
 		nil,
 		nil,
 	)
 	c.serviceCacheFilesCachedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_file_cache_items_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_file_cache_items_total"),
 		"Total number of files whose contents were ever added to the cache (since service startup)",
 		nil,
 		nil,
 	)
 	c.serviceCacheFilesFlushedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_file_cache_items_flushed_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_file_cache_items_flushed_total"),
 		"Total number of file handles that have been removed from the cache (since service startup)",
 		nil,
 		nil,
 	)
 	c.serviceCacheURICacheFlushesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_uri_cache_flushes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_uri_cache_flushes_total"),
 		"Total number of URI cache flushes (since service startup)",
 		[]string{"mode"},
 		nil,
 	)
 	c.serviceCacheURICacheQueriesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_uri_cache_queries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_uri_cache_queries_total"),
 		"Total number of uri cache queries (hits + misses)",
 		[]string{"mode"},
 		nil,
 	)
 	c.serviceCacheURICacheHitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_uri_cache_hits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_uri_cache_hits_total"),
 		"Total number of successful lookups in the URI cache (since service startup)",
 		[]string{"mode"},
 		nil,
 	)
 	c.serviceCacheURIsCached = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_uri_cache_items"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_uri_cache_items"),
 		"Number of URI information blocks currently in the cache",
 		[]string{"mode"},
 		nil,
 	)
 	c.serviceCacheURIsCachedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_uri_cache_items_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_uri_cache_items_total"),
 		"Total number of URI information blocks added to the cache (since service startup)",
 		[]string{"mode"},
 		nil,
 	)
 	c.serviceCacheURIsFlushedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_uri_cache_items_flushed_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_uri_cache_items_flushed_total"),
 		"The number of URI information blocks that have been removed from the cache (since service startup)",
 		[]string{"mode"},
 		nil,
 	)
 	c.serviceCacheMetadataCached = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_metadata_cache_items"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_metadata_cache_items"),
 		"Number of metadata information blocks currently present in cache",
 		nil,
 		nil,
 	)
 	c.serviceCacheMetadataCacheFlushes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_metadata_cache_flushes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_metadata_cache_flushes_total"),
 		"Total number of metadata cache flushes (since service startup)",
 		nil,
 		nil,
 	)
 	c.serviceCacheMetadataCacheQueriesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_metadata_cache_queries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_metadata_cache_queries_total"),
 		"Total metadata cache queries (hits + misses)",
 		nil,
 		nil,
 	)
 	c.serviceCacheMetadataCacheHitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_metadata_cache_hits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_metadata_cache_hits_total"),
 		"Total number of successful lookups in the metadata cache (since service startup)",
 		nil,
 		nil,
 	)
 	c.serviceCacheMetadataCachedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_metadata_cache_items_cached_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_metadata_cache_items_cached_total"),
 		"Total number of metadata information blocks added to the cache (since service startup)",
 		nil,
 		nil,
 	)
 	c.serviceCacheMetadataFlushedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_metadata_cache_items_flushed_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_metadata_cache_items_flushed_total"),
 		"Total number of metadata information blocks removed from the cache (since service startup)",
 		nil,
 		nil,
 	)
 	c.serviceCacheOutputCacheActiveFlushedItems = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_output_cache_active_flushed_items"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_output_cache_active_flushed_items"),
 		"",
 		nil,
 		nil,
 	)
 	c.serviceCacheOutputCacheItems = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_output_cache_items"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_output_cache_items"),
 		"Number of items current present in output cache",
 		nil,
 		nil,
 	)
 	c.serviceCacheOutputCacheMemoryUsage = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_output_cache_memory_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_output_cache_memory_bytes"),
 		"Current number of bytes used by output cache",
 		nil,
 		nil,
 	)
 	c.serviceCacheOutputCacheQueriesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_output_cache_queries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_output_cache_queries_total"),
 		"Total output cache queries (hits + misses)",
 		nil,
 		nil,
 	)
 	c.serviceCacheOutputCacheHitsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_output_cache_hits_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_output_cache_hits_total"),
 		"Total number of successful lookups in output cache (since service startup)",
 		nil,
 		nil,
 	)
 	c.serviceCacheOutputCacheFlushedItemsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_output_cache_items_flushed_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_output_cache_items_flushed_total"),
 		"Total number of items flushed from output cache (since service startup)",
 		nil,
 		nil,
 	)
 	c.serviceCacheOutputCacheFlushesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "server_output_cache_flushes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "server_output_cache_flushes_total"),
 		"Total number of flushes of output cache (since service startup)",
 		nil,
 		nil,
@@ -940,7 +940,7 @@ func getIISVersion(logger *slog.Logger) simpleVersion {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collectWebService(ctx, logger, ch); err != nil {
 		logger.Error("failed collecting iis metrics",
@@ -1068,7 +1068,7 @@ func dedupIISNames[V hasGetIISName](services []V) map[string]V {
 	return webServiceDeDuplicated
 }
 
-func (c *Collector) collectWebService(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectWebService(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var webService []perflibWebService
@@ -1363,7 +1363,7 @@ var applicationStates = map[uint32]string{
 	7: "Delete Pending",
 }
 
-func (c *Collector) collectAPP_POOL_WAS(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectAPP_POOL_WAS(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var APP_POOL_WAS []perflibAPP_POOL_WAS
@@ -1543,7 +1543,7 @@ type perflibW3SVC_W3WP_IIS8 struct {
 	WebSocketConnectionsRejected float64 `perflib:"WebSocket Connections Rejected / Sec"`
 }
 
-func (c *Collector) collectW3SVC_W3WP(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectW3SVC_W3WP(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var W3SVC_W3WP []perflibW3SVC_W3WP
@@ -1945,7 +1945,7 @@ type perflibWebServiceCache struct {
 	ServiceCache_OutputCacheQueriesTotal       float64
 }
 
-func (c *Collector) collectWebServiceCache(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectWebServiceCache(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var WebServiceCache []perflibWebServiceCache

internal/collector/license/license.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/headers/slc"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -63,7 +63,7 @@ func (c *Collector) Close(_ *slog.Logger) error {
 
 func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	c.licenseStatus = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "status"),
+		prometheus.BuildFQName(types.Namespace, Name, "status"),
 		"Status of windows license",
 		[]string{"state"},
 		nil,
@@ -74,7 +74,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ch); err != nil {
 		logger.Error("failed collecting license metrics",

internal/collector/logical_disk/logical_disk.go

@@ -13,7 +13,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 	"golang.org/x/sys/windows"
@@ -27,8 +27,8 @@ type Config struct {
 }
 
 var ConfigDefaults = Config{
-	VolumeInclude: types2.RegExpAny,
+	VolumeInclude: types.RegExpAny,
-	VolumeExclude: types2.RegExpEmpty,
+	VolumeExclude: types.RegExpEmpty,
 }
 
 // A Collector is a Prometheus Collector for perflib logicalDisk metrics.
@@ -133,124 +133,124 @@ func (c *Collector) Close(_ *slog.Logger) error {
 
 func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	c.information = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "info"),
+		prometheus.BuildFQName(types.Namespace, Name, "info"),
 		"A metric with a constant '1' value labeled with logical disk information",
 		[]string{"disk", "type", "volume", "volume_name", "filesystem", "serial_number"},
 		nil,
 	)
 	c.readOnly = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "readonly"),
+		prometheus.BuildFQName(types.Namespace, Name, "readonly"),
 		"Whether the logical disk is read-only",
 		[]string{"volume"},
 		nil,
 	)
 	c.requestsQueued = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "requests_queued"),
+		prometheus.BuildFQName(types.Namespace, Name, "requests_queued"),
 		"The number of requests queued to the disk (LogicalDisk.CurrentDiskQueueLength)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.avgReadQueue = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "avg_read_requests_queued"),
+		prometheus.BuildFQName(types.Namespace, Name, "avg_read_requests_queued"),
 		"Average number of read requests that were queued for the selected disk during the sample interval (LogicalDisk.AvgDiskReadQueueLength)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.avgWriteQueue = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "avg_write_requests_queued"),
+		prometheus.BuildFQName(types.Namespace, Name, "avg_write_requests_queued"),
 		"Average number of write requests that were queued for the selected disk during the sample interval (LogicalDisk.AvgDiskWriteQueueLength)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.readBytesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "read_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "read_bytes_total"),
 		"The number of bytes transferred from the disk during read operations (LogicalDisk.DiskReadBytesPerSec)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.readsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "reads_total"),
 		"The number of read operations on the disk (LogicalDisk.DiskReadsPerSec)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.writeBytesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "write_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "write_bytes_total"),
 		"The number of bytes transferred to the disk during write operations (LogicalDisk.DiskWriteBytesPerSec)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.writesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "writes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "writes_total"),
 		"The number of write operations on the disk (LogicalDisk.DiskWritesPerSec)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.readTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "read_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "read_seconds_total"),
 		"Seconds that the disk was busy servicing read requests (LogicalDisk.PercentDiskReadTime)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.writeTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "write_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "write_seconds_total"),
 		"Seconds that the disk was busy servicing write requests (LogicalDisk.PercentDiskWriteTime)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.freeSpace = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "free_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "free_bytes"),
 		"Free space in bytes, updates every 10-15 min (LogicalDisk.PercentFreeSpace)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.totalSpace = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "size_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "size_bytes"),
 		"Total space in bytes, updates every 10-15 min (LogicalDisk.PercentFreeSpace_Base)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.idleTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "idle_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "idle_seconds_total"),
 		"Seconds that the disk was idle (LogicalDisk.PercentIdleTime)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.splitIOs = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "split_ios_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "split_ios_total"),
 		"The number of I/Os to the disk were split into multiple I/Os (LogicalDisk.SplitIOPerSec)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.readLatency = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "read_latency_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "read_latency_seconds_total"),
 		"Shows the average time, in seconds, of a read operation from the disk (LogicalDisk.AvgDiskSecPerRead)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.writeLatency = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "write_latency_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "write_latency_seconds_total"),
 		"Shows the average time, in seconds, of a write operation to the disk (LogicalDisk.AvgDiskSecPerWrite)",
 		[]string{"volume"},
 		nil,
 	)
 
 	c.readWriteLatency = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "read_write_latency_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "read_write_latency_seconds_total"),
 		"Shows the time, in seconds, of the average disk transfer (LogicalDisk.AvgDiskSecPerTransfer)",
 		[]string{"volume"},
 		nil,
@@ -261,7 +261,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ctx, logger, ch); err != nil {
 		logger.Error("failed collecting logical_disk metrics",
@@ -297,7 +297,7 @@ type logicalDisk struct {
 	AvgDiskSecPerTransfer   float64 `perflib:"Avg. Disk sec/Transfer"`
 }
 
-func (c *Collector) collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var (

internal/collector/logon/logon.go

@@ -7,7 +7,7 @@ import (
 	"log/slog"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -61,7 +61,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 	c.wmiClient = wmiClient
 	c.logonType = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "logon_type"),
+		prometheus.BuildFQName(types.Namespace, Name, "logon_type"),
 		"Number of active logon sessions (LogonSession.LogonType)",
 		[]string{"status"},
 		nil,
@@ -72,7 +72,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ch); err != nil {
 		logger.Error("failed collecting user metrics",

internal/collector/memory/memory.go

@@ -13,7 +13,7 @@ import (
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/headers/sysinfoapi"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -98,223 +98,223 @@ func (c *Collector) Close(_ *slog.Logger) error {
 
 func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	c.availableBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "available_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "available_bytes"),
 		"The amount of physical memory immediately available for allocation to a process or for system use. It is equal to the sum of memory assigned to"+
 			" the standby (cached), free and zero page lists (AvailableBytes)",
 		nil,
 		nil,
 	)
 	c.cacheBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cache_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "cache_bytes"),
 		"(CacheBytes)",
 		nil,
 		nil,
 	)
 	c.cacheBytesPeak = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cache_bytes_peak"),
+		prometheus.BuildFQName(types.Namespace, Name, "cache_bytes_peak"),
 		"(CacheBytesPeak)",
 		nil,
 		nil,
 	)
 	c.cacheFaultsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cache_faults_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cache_faults_total"),
 		"Number of faults which occur when a page sought in the file system cache is not found there and must be retrieved from elsewhere in memory (soft fault) "+
 			"or from disk (hard fault) (Cache Faults/sec)",
 		nil,
 		nil,
 	)
 	c.commitLimit = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "commit_limit"),
+		prometheus.BuildFQName(types.Namespace, Name, "commit_limit"),
 		"(CommitLimit)",
 		nil,
 		nil,
 	)
 	c.committedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "committed_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "committed_bytes"),
 		"(CommittedBytes)",
 		nil,
 		nil,
 	)
 	c.demandZeroFaultsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "demand_zero_faults_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "demand_zero_faults_total"),
 		"The number of zeroed pages required to satisfy faults. Zeroed pages, pages emptied of previously stored data and filled with zeros, are a security"+
 			" feature of Windows that prevent processes from seeing data stored by earlier processes that used the memory space (Demand Zero Faults/sec)",
 		nil,
 		nil,
 	)
 	c.freeAndZeroPageListBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "free_and_zero_page_list_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "free_and_zero_page_list_bytes"),
 		"The amount of physical memory, in bytes, that is assigned to the free and zero page lists. This memory does not contain cached data. It is immediately"+
 			" available for allocation to a process or for system use (FreeAndZeroPageListBytes)",
 		nil,
 		nil,
 	)
 	c.freeSystemPageTableEntries = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "free_system_page_table_entries"),
+		prometheus.BuildFQName(types.Namespace, Name, "free_system_page_table_entries"),
 		"(FreeSystemPageTableEntries)",
 		nil,
 		nil,
 	)
 	c.modifiedPageListBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "modified_page_list_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "modified_page_list_bytes"),
 		"The amount of physical memory, in bytes, that is assigned to the modified page list. This memory contains cached data and code that is not actively in "+
 			"use by processes, the system and the system cache (ModifiedPageListBytes)",
 		nil,
 		nil,
 	)
 	c.pageFaultsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "page_faults_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "page_faults_total"),
 		"Overall rate at which faulted pages are handled by the processor (Page Faults/sec)",
 		nil,
 		nil,
 	)
 	c.swapPageReadsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "swap_page_reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "swap_page_reads_total"),
 		"Number of disk page reads (a single read operation reading several pages is still only counted once) (PageReadsPersec)",
 		nil,
 		nil,
 	)
 	c.swapPagesReadTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "swap_pages_read_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "swap_pages_read_total"),
 		"Number of pages read across all page reads (ie counting all pages read even if they are read in a single operation) (PagesInputPersec)",
 		nil,
 		nil,
 	)
 	c.swapPagesWrittenTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "swap_pages_written_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "swap_pages_written_total"),
 		"Number of pages written across all page writes (ie counting all pages written even if they are written in a single operation) (PagesOutputPersec)",
 		nil,
 		nil,
 	)
 	c.swapPageOperationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "swap_page_operations_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "swap_page_operations_total"),
 		"Total number of swap page read and writes (PagesPersec)",
 		nil,
 		nil,
 	)
 	c.swapPageWritesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "swap_page_writes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "swap_page_writes_total"),
 		"Number of disk page writes (a single write operation writing several pages is still only counted once) (PageWritesPersec)",
 		nil,
 		nil,
 	)
 	c.poolNonPagedAllocationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pool_nonpaged_allocs_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "pool_nonpaged_allocs_total"),
 		"The number of calls to allocate space in the nonpaged pool. The nonpaged pool is an area of system memory area for objects that cannot be written"+
 			" to disk, and must remain in physical memory as long as they are allocated (PoolNonpagedAllocs)",
 		nil,
 		nil,
 	)
 	c.poolNonPagedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pool_nonpaged_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "pool_nonpaged_bytes"),
 		"Number of bytes in the non-paged pool, an area of the system virtual memory that is used for objects that cannot be written to disk, but must "+
 			"remain in physical memory as long as they are allocated (PoolNonpagedBytes)",
 		nil,
 		nil,
 	)
 	c.poolPagedAllocationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pool_paged_allocs_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "pool_paged_allocs_total"),
 		"Number of calls to allocate space in the paged pool, regardless of the amount of space allocated in each call (PoolPagedAllocs)",
 		nil,
 		nil,
 	)
 	c.poolPagedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pool_paged_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "pool_paged_bytes"),
 		"(PoolPagedBytes)",
 		nil,
 		nil,
 	)
 	c.poolPagedResidentBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pool_paged_resident_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "pool_paged_resident_bytes"),
 		"The size, in bytes, of the portion of the paged pool that is currently resident and active in physical memory. The paged pool is an area of the "+
 			"system virtual memory that is used for objects that can be written to disk when they are not being used (PoolPagedResidentBytes)",
 		nil,
 		nil,
 	)
 	c.standbyCacheCoreBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "standby_cache_core_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "standby_cache_core_bytes"),
 		"The amount of physical memory, in bytes, that is assigned to the core standby cache page lists. This memory contains cached data and code that is "+
 			"not actively in use by processes, the system and the system cache (StandbyCacheCoreBytes)",
 		nil,
 		nil,
 	)
 	c.standbyCacheNormalPriorityBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "standby_cache_normal_priority_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "standby_cache_normal_priority_bytes"),
 		"The amount of physical memory, in bytes, that is assigned to the normal priority standby cache page lists. This memory contains cached data and "+
 			"code that is not actively in use by processes, the system and the system cache (StandbyCacheNormalPriorityBytes)",
 		nil,
 		nil,
 	)
 	c.standbyCacheReserveBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "standby_cache_reserve_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "standby_cache_reserve_bytes"),
 		"The amount of physical memory, in bytes, that is assigned to the reserve standby cache page lists. This memory contains cached data and code "+
 			"that is not actively in use by processes, the system and the system cache (StandbyCacheReserveBytes)",
 		nil,
 		nil,
 	)
 	c.systemCacheResidentBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "system_cache_resident_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "system_cache_resident_bytes"),
 		"The size, in bytes, of the portion of the system file cache which is currently resident and active in physical memory (SystemCacheResidentBytes)",
 		nil,
 		nil,
 	)
 	c.systemCodeResidentBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "system_code_resident_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "system_code_resident_bytes"),
 		"The size, in bytes, of the pageable operating system code that is currently resident and active in physical memory (SystemCodeResidentBytes)",
 		nil,
 		nil,
 	)
 	c.systemCodeTotalBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "system_code_total_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "system_code_total_bytes"),
 		"The size, in bytes, of the pageable operating system code currently mapped into the system virtual address space (SystemCodeTotalBytes)",
 		nil,
 		nil,
 	)
 	c.systemDriverResidentBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "system_driver_resident_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "system_driver_resident_bytes"),
 		"The size, in bytes, of the pageable physical memory being used by device drivers. It is the working set (physical memory area) of the drivers (SystemDriverResidentBytes)",
 		nil,
 		nil,
 	)
 	c.systemDriverTotalBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "system_driver_total_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "system_driver_total_bytes"),
 		"The size, in bytes, of the pageable virtual memory currently being used by device drivers. Pageable memory can be written to disk when it is not being used (SystemDriverTotalBytes)",
 		nil,
 		nil,
 	)
 	c.transitionFaultsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "transition_faults_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "transition_faults_total"),
 		"Number of faults rate at which page faults are resolved by recovering pages that were being used by another process sharing the page, or were on the "+
 			"modified page list or the standby list, or were being written to disk at the time of the page fault (TransitionFaultsPersec)",
 		nil,
 		nil,
 	)
 	c.transitionPagesRepurposedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "transition_pages_repurposed_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "transition_pages_repurposed_total"),
 		"Transition Pages RePurposed is the rate at which the number of transition cache pages were reused for a different purpose (TransitionPagesRePurposedPersec)",
 		nil,
 		nil,
 	)
 	c.writeCopiesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "write_copies_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "write_copies_total"),
 		"The number of page faults caused by attempting to write that were satisfied by copying the page from elsewhere in physical memory (WriteCopiesPersec)",
 		nil,
 		nil,
 	)
 	c.processMemoryLimitBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "process_memory_limit_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "process_memory_limit_bytes"),
 		"The size of the user-mode portion of the virtual address space of the calling process, in bytes. This value depends on the type of process, the type of processor, and the configuration of the operating system.",
 		nil,
 		nil,
 	)
 	c.physicalMemoryTotalBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "physical_total_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "physical_total_bytes"),
 		"The amount of actual physical memory, in bytes.",
 		nil,
 		nil,
 	)
 	c.physicalMemoryFreeBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "physical_free_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "physical_free_bytes"),
 		"The amount of physical memory currently available, in bytes. This is the amount of physical memory that can be immediately reused without having to write its contents to disk first. It is the sum of the size of the standby, free, and zero lists.",
 		nil,
 		nil,
@@ -325,7 +325,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	errs := make([]error, 0, 2)
@@ -413,7 +413,7 @@ type memory struct {
 	WriteCopiesPersec               float64 `perflib:"Write Copies/sec"`
 }
 
-func (c *Collector) collectPerformanceData(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectPerformanceData(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var dst []memory

internal/collector/msmq/msmq.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus-community/windows_exporter/internal/utils"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
@@ -89,25 +89,25 @@ func (c *Collector) Build(logger *slog.Logger, wmiClient *wmi.Client) error {
 	}
 
 	c.bytesInJournalQueue = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "bytes_in_journal_queue"),
+		prometheus.BuildFQName(types.Namespace, Name, "bytes_in_journal_queue"),
 		"Size of queue journal in bytes",
 		[]string{"name"},
 		nil,
 	)
 	c.bytesInQueue = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "bytes_in_queue"),
+		prometheus.BuildFQName(types.Namespace, Name, "bytes_in_queue"),
 		"Size of queue in bytes",
 		[]string{"name"},
 		nil,
 	)
 	c.messagesInJournalQueue = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "messages_in_journal_queue"),
+		prometheus.BuildFQName(types.Namespace, Name, "messages_in_journal_queue"),
 		"Count messages in queue journal",
 		[]string{"name"},
 		nil,
 	)
 	c.messagesInQueue = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "messages_in_queue"),
+		prometheus.BuildFQName(types.Namespace, Name, "messages_in_queue"),
 		"Count messages in queue",
 		[]string{"name"},
 		nil,
@@ -118,7 +118,7 @@ func (c *Collector) Build(logger *slog.Logger, wmiClient *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ch); err != nil {
 		logger.Error("failed collecting msmq metrics",

internal/collector/net/net.go

@@ -15,7 +15,7 @@ import (
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perfdata"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus-community/windows_exporter/internal/utils"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
@@ -31,8 +31,8 @@ type Config struct {
 }
 
 var ConfigDefaults = Config{
-	NicExclude: types2.RegExpEmpty,
+	NicExclude: types.RegExpEmpty,
-	NicInclude: types2.RegExpAny,
+	NicInclude: types.RegExpAny,
 	CollectorsEnabled: []string{
 		"metrics",
 		"nic_addresses",
@@ -182,91 +182,91 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 	}
 
 	c.bytesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "bytes_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "bytes_received_total"),
 		"(Network.BytesReceivedPerSec)",
 		[]string{"nic"},
 		nil,
 	)
 	c.bytesSentTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "bytes_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "bytes_sent_total"),
 		"(Network.BytesSentPerSec)",
 		[]string{"nic"},
 		nil,
 	)
 	c.bytesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "bytes_total"),
 		"(Network.BytesTotalPerSec)",
 		[]string{"nic"},
 		nil,
 	)
 	c.outputQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "output_queue_length_packets"),
+		prometheus.BuildFQName(types.Namespace, Name, "output_queue_length_packets"),
 		"(Network.OutputQueueLength)",
 		[]string{"nic"},
 		nil,
 	)
 	c.packetsOutboundDiscarded = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "packets_outbound_discarded_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "packets_outbound_discarded_total"),
 		"(Network.PacketsOutboundDiscarded)",
 		[]string{"nic"},
 		nil,
 	)
 	c.packetsOutboundErrors = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "packets_outbound_errors_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "packets_outbound_errors_total"),
 		"(Network.PacketsOutboundErrors)",
 		[]string{"nic"},
 		nil,
 	)
 	c.packetsReceivedDiscarded = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "packets_received_discarded_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "packets_received_discarded_total"),
 		"(Network.PacketsReceivedDiscarded)",
 		[]string{"nic"},
 		nil,
 	)
 	c.packetsReceivedErrors = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "packets_received_errors_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "packets_received_errors_total"),
 		"(Network.PacketsReceivedErrors)",
 		[]string{"nic"},
 		nil,
 	)
 	c.packetsReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "packets_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "packets_received_total"),
 		"(Network.PacketsReceivedPerSec)",
 		[]string{"nic"},
 		nil,
 	)
 	c.packetsReceivedUnknown = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "packets_received_unknown_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "packets_received_unknown_total"),
 		"(Network.PacketsReceivedUnknown)",
 		[]string{"nic"},
 		nil,
 	)
 	c.packetsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "packets_total"),
 		"(Network.PacketsPerSec)",
 		[]string{"nic"},
 		nil,
 	)
 	c.packetsSentTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "packets_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "packets_sent_total"),
 		"(Network.PacketsSentPerSec)",
 		[]string{"nic"},
 		nil,
 	)
 	c.currentBandwidth = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "current_bandwidth_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "current_bandwidth_bytes"),
 		"(Network.CurrentBandwidth)",
 		[]string{"nic"},
 		nil,
 	)
 	c.nicAddressInfo = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "nic_address_info"),
+		prometheus.BuildFQName(types.Namespace, Name, "nic_address_info"),
 		"A metric with a constant '1' value labeled with the network interface's address information.",
 		[]string{"nic", "friendly_name", "address", "family"},
 		nil,
 	)
 	c.routeInfo = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "route_info"),
+		prometheus.BuildFQName(types.Namespace, Name, "route_info"),
 		"A metric with a constant '1' value labeled with the network interface's route information.",
 		[]string{"nic", "src", "dest", "metric"},
 		nil,
@@ -277,7 +277,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	if slices.Contains(c.config.CollectorsEnabled, "metrics") {
@@ -303,7 +303,7 @@ func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch c
 	return nil
 }
 
-func (c *Collector) collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	var dst []perflibNetworkInterface
 
 	if err := perflib.UnmarshalObject(ctx.PerfObjects["Network Interface"], &dst, logger); err != nil {

internal/collector/nps/nps.go

@@ -6,7 +6,7 @@ import (
 	"log/slog"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -85,152 +85,152 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 	c.wmiClient = wmiClient
 	c.accessAccepts = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_accepts"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_accepts"),
 		"(AccessAccepts)",
 		nil,
 		nil,
 	)
 	c.accessChallenges = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_challenges"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_challenges"),
 		"(AccessChallenges)",
 		nil,
 		nil,
 	)
 	c.accessRejects = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_rejects"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_rejects"),
 		"(AccessRejects)",
 		nil,
 		nil,
 	)
 	c.accessRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_requests"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_requests"),
 		"(AccessRequests)",
 		nil,
 		nil,
 	)
 	c.accessBadAuthenticators = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_bad_authenticators"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_bad_authenticators"),
 		"(BadAuthenticators)",
 		nil,
 		nil,
 	)
 	c.accessDroppedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_dropped_packets"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_dropped_packets"),
 		"(DroppedPackets)",
 		nil,
 		nil,
 	)
 	c.accessInvalidRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_invalid_requests"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_invalid_requests"),
 		"(InvalidRequests)",
 		nil,
 		nil,
 	)
 	c.accessMalformedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_malformed_packets"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_malformed_packets"),
 		"(MalformedPackets)",
 		nil,
 		nil,
 	)
 	c.accessPacketsReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_packets_received"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_packets_received"),
 		"(PacketsReceived)",
 		nil,
 		nil,
 	)
 	c.accessPacketsSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_packets_sent"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_packets_sent"),
 		"(PacketsSent)",
 		nil,
 		nil,
 	)
 	c.accessServerResetTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_server_reset_time"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_server_reset_time"),
 		"(ServerResetTime)",
 		nil,
 		nil,
 	)
 	c.accessServerUpTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_server_up_time"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_server_up_time"),
 		"(ServerUpTime)",
 		nil,
 		nil,
 	)
 	c.accessUnknownType = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "access_unknown_type"),
+		prometheus.BuildFQName(types.Namespace, Name, "access_unknown_type"),
 		"(UnknownType)",
 		nil,
 		nil,
 	)
 
 	c.accountingRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "accounting_requests"),
+		prometheus.BuildFQName(types.Namespace, Name, "accounting_requests"),
 		"(AccountingRequests)",
 		nil,
 		nil,
 	)
 	c.accountingResponses = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "accounting_responses"),
+		prometheus.BuildFQName(types.Namespace, Name, "accounting_responses"),
 		"(AccountingResponses)",
 		nil,
 		nil,
 	)
 	c.accountingBadAuthenticators = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "accounting_bad_authenticators"),
+		prometheus.BuildFQName(types.Namespace, Name, "accounting_bad_authenticators"),
 		"(BadAuthenticators)",
 		nil,
 		nil,
 	)
 	c.accountingDroppedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "accounting_dropped_packets"),
+		prometheus.BuildFQName(types.Namespace, Name, "accounting_dropped_packets"),
 		"(DroppedPackets)",
 		nil,
 		nil,
 	)
 	c.accountingInvalidRequests = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "accounting_invalid_requests"),
+		prometheus.BuildFQName(types.Namespace, Name, "accounting_invalid_requests"),
 		"(InvalidRequests)",
 		nil,
 		nil,
 	)
 	c.accountingMalformedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "accounting_malformed_packets"),
+		prometheus.BuildFQName(types.Namespace, Name, "accounting_malformed_packets"),
 		"(MalformedPackets)",
 		nil,
 		nil,
 	)
 	c.accountingNoRecord = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "accounting_no_record"),
+		prometheus.BuildFQName(types.Namespace, Name, "accounting_no_record"),
 		"(NoRecord)",
 		nil,
 		nil,
 	)
 	c.accountingPacketsReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "accounting_packets_received"),
+		prometheus.BuildFQName(types.Namespace, Name, "accounting_packets_received"),
 		"(PacketsReceived)",
 		nil,
 		nil,
 	)
 	c.accountingPacketsSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "accounting_packets_sent"),
+		prometheus.BuildFQName(types.Namespace, Name, "accounting_packets_sent"),
 		"(PacketsSent)",
 		nil,
 		nil,
 	)
 	c.accountingServerResetTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "accounting_server_reset_time"),
+		prometheus.BuildFQName(types.Namespace, Name, "accounting_server_reset_time"),
 		"(ServerResetTime)",
 		nil,
 		nil,
 	)
 	c.accountingServerUpTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "accounting_server_up_time"),
+		prometheus.BuildFQName(types.Namespace, Name, "accounting_server_up_time"),
 		"(ServerUpTime)",
 		nil,
 		nil,
 	)
 	c.accountingUnknownType = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "accounting_unknown_type"),
+		prometheus.BuildFQName(types.Namespace, Name, "accounting_unknown_type"),
 		"(UnknownType)",
 		nil,
 		nil,
@@ -241,7 +241,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.CollectAccept(ch); err != nil {
 		logger.Error(fmt.Sprintf("failed collecting NPS accept data: %s", err))

internal/collector/os/os.go

@@ -17,7 +17,7 @@ import (
 	"github.com/prometheus-community/windows_exporter/internal/headers/psapi"
 	"github.com/prometheus-community/windows_exporter/internal/headers/sysinfoapi"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 	"golang.org/x/sys/windows"
@@ -124,7 +124,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 	}
 
 	c.osInformation = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "info"),
+		prometheus.BuildFQName(types.Namespace, Name, "info"),
 		`Contains full product name & version in labels. Note that the "major_version" for Windows 11 is \"10\"; a build number greater than 22000 represents Windows 11.`,
 		nil,
 		prometheus.Labels{
@@ -138,7 +138,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 	)
 
 	c.hostname = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "hostname"),
+		prometheus.BuildFQName(types.Namespace, Name, "hostname"),
 		"Labelled system hostname information as provided by ComputerSystem.DNSHostName and ComputerSystem.Domain",
 		[]string{
 			"hostname",
@@ -148,73 +148,73 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 		nil,
 	)
 	c.pagingLimitBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "paging_limit_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "paging_limit_bytes"),
 		"OperatingSystem.SizeStoredInPagingFiles",
 		nil,
 		nil,
 	)
 	c.pagingFreeBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "paging_free_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "paging_free_bytes"),
 		"OperatingSystem.FreeSpaceInPagingFiles",
 		nil,
 		nil,
 	)
 	c.physicalMemoryFreeBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "physical_memory_free_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "physical_memory_free_bytes"),
 		"Deprecated: Use `windows_memory_physical_free_bytes` instead.",
 		nil,
 		nil,
 	)
 	c.time = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "time"),
+		prometheus.BuildFQName(types.Namespace, Name, "time"),
 		"Deprecated: Use windows_time_current_timestamp_seconds instead.",
 		nil,
 		nil,
 	)
 	c.timezone = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "timezone"),
+		prometheus.BuildFQName(types.Namespace, Name, "timezone"),
 		"Deprecated: Use windows_time_timezone instead.",
 		[]string{"timezone"},
 		nil,
 	)
 	c.processes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "processes"),
+		prometheus.BuildFQName(types.Namespace, Name, "processes"),
 		"Deprecated: Use `windows_system_processes` instead.",
 		nil,
 		nil,
 	)
 	c.processesLimit = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "processes_limit"),
+		prometheus.BuildFQName(types.Namespace, Name, "processes_limit"),
 		"Deprecated: Use `windows_system_process_limit` instead.",
 		nil,
 		nil,
 	)
 	c.processMemoryLimitBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "process_memory_limit_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "process_memory_limit_bytes"),
 		"Deprecated: Use `windows_memory_process_memory_limit_bytes` instead.",
 		nil,
 		nil,
 	)
 	c.users = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "users"),
+		prometheus.BuildFQName(types.Namespace, Name, "users"),
 		"Deprecated: Use `count(windows_logon_logon_type)` instead.",
 		nil,
 		nil,
 	)
 	c.virtualMemoryBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "virtual_memory_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "virtual_memory_bytes"),
 		"Deprecated: Use `windows_memory_commit_limit` instead.",
 		nil,
 		nil,
 	)
 	c.visibleMemoryBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "visible_memory_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "visible_memory_bytes"),
 		"Deprecated: Use `windows_memory_physical_total_bytes` instead.",
 		nil,
 		nil,
 	)
 	c.virtualMemoryFreeBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "virtual_memory_free_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "virtual_memory_free_bytes"),
 		"Deprecated: Use `windows_memory_commit_limit - windows_memory_committed_bytes` instead.",
 		nil,
 		nil,
@@ -225,7 +225,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	errs := make([]error, 0, 5)
@@ -382,7 +382,7 @@ func (c *Collector) collectMemory(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
-func (c *Collector) collectPaging(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectPaging(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	// Get total allocation of paging files across all disks.
 	memManKey, err := registry.OpenKey(registry.LOCAL_MACHINE, `SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management`, registry.QUERY_VALUE)
 	if err != nil {

internal/collector/perfdata/perfdata.go

@@ -12,7 +12,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perfdata"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -114,7 +114,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	if err := c.collect(ch); err != nil {
 		logger.Error("failed collecting performance data metrics",
 			slog.Any("err", err),
@@ -153,7 +153,7 @@ func (c *Collector) collect(ch chan<- prometheus.Metric) error {
 
 				ch <- prometheus.MustNewConstMetric(
 					prometheus.NewDesc(
-						sanitizeMetricName(fmt.Sprintf("%s_perfdata_%s_%s", types2.Namespace, object.Object, counter)),
+						sanitizeMetricName(fmt.Sprintf("%s_perfdata_%s_%s", types.Namespace, object.Object, counter)),
 						fmt.Sprintf("Performance data for \\%s\\%s", object.Object, counter),
 						nil,
 						labels,

internal/collector/perfdata/perfdata_collector_test.go

@@ -11,7 +11,7 @@ import (
 	"regexp"
 	"testing"
 
-	perfdata2 "github.com/prometheus-community/windows_exporter/internal/collector/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/collector/perfdata"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"github.com/stretchr/testify/assert"
@@ -19,7 +19,7 @@ import (
 )
 
 type collectorAdapter struct {
-	perfdata2.Collector
+	perfdata.Collector
 }
 
 // Describe implements the prometheus.Collector interface.
@@ -40,27 +40,27 @@ func TestCollector(t *testing.T) {
 	for _, tc := range []struct {
 		object          string
 		instances       []string
-		counters        map[string]perfdata2.Counter
+		counters        map[string]perfdata.Counter
 		expectedMetrics *regexp.Regexp
 	}{
 		{
 			object:          "Memory",
 			instances:       nil,
-			counters:        map[string]perfdata2.Counter{"Available Bytes": {Type: "gauge"}},
+			counters:        map[string]perfdata.Counter{"Available Bytes": {Type: "gauge"}},
 			expectedMetrics: regexp.MustCompile(`^# HELP windows_perfdata_memory_available_bytes Performance data for \\\\Memory\\\\Available Bytes\s*# TYPE windows_perfdata_memory_available_bytes gauge\s*windows_perfdata_memory_available_bytes \d`),
 		},
 		{
 			object:          "Process",
 			instances:       []string{"*"},
-			counters:        map[string]perfdata2.Counter{"Thread Count": {Type: "counter"}},
+			counters:        map[string]perfdata.Counter{"Thread Count": {Type: "counter"}},
 			expectedMetrics: regexp.MustCompile(`^# HELP windows_perfdata_process_thread_count Performance data for \\\\Process\\\\Thread Count\s*# TYPE windows_perfdata_process_thread_count counter\s*windows_perfdata_process_thread_count\{instance=".+"} \d`),
 		},
 	} {
 		t.Run(tc.object, func(t *testing.T) {
 			t.Parallel()
 
-			perfDataCollector := perfdata2.New(&perfdata2.Config{
+			perfDataCollector := perfdata.New(&perfdata.Config{
-				Objects: []perfdata2.Object{
+				Objects: []perfdata.Object{
 					{
 						Object:    tc.object,
 						Instances: tc.instances,

internal/collector/physical_disk/physical_disk.go

@@ -10,7 +10,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -23,8 +23,8 @@ type Config struct {
 }
 
 var ConfigDefaults = Config{
-	DiskInclude: types2.RegExpAny,
+	DiskInclude: types.RegExpAny,
-	DiskExclude: types2.RegExpEmpty,
+	DiskExclude: types.RegExpEmpty,
 }
 
 // A Collector is a Prometheus Collector for perflib PhysicalDisk metrics.
@@ -115,84 +115,84 @@ func (c *Collector) Close(_ *slog.Logger) error {
 
 func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	c.requestsQueued = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "requests_queued"),
+		prometheus.BuildFQName(types.Namespace, Name, "requests_queued"),
 		"The number of requests queued to the disk (PhysicalDisk.CurrentDiskQueueLength)",
 		[]string{"disk"},
 		nil,
 	)
 
 	c.readBytesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "read_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "read_bytes_total"),
 		"The number of bytes transferred from the disk during read operations (PhysicalDisk.DiskReadBytesPerSec)",
 		[]string{"disk"},
 		nil,
 	)
 
 	c.readsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "reads_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "reads_total"),
 		"The number of read operations on the disk (PhysicalDisk.DiskReadsPerSec)",
 		[]string{"disk"},
 		nil,
 	)
 
 	c.writeBytesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "write_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "write_bytes_total"),
 		"The number of bytes transferred to the disk during write operations (PhysicalDisk.DiskWriteBytesPerSec)",
 		[]string{"disk"},
 		nil,
 	)
 
 	c.writesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "writes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "writes_total"),
 		"The number of write operations on the disk (PhysicalDisk.DiskWritesPerSec)",
 		[]string{"disk"},
 		nil,
 	)
 
 	c.readTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "read_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "read_seconds_total"),
 		"Seconds that the disk was busy servicing read requests (PhysicalDisk.PercentDiskReadTime)",
 		[]string{"disk"},
 		nil,
 	)
 
 	c.writeTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "write_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "write_seconds_total"),
 		"Seconds that the disk was busy servicing write requests (PhysicalDisk.PercentDiskWriteTime)",
 		[]string{"disk"},
 		nil,
 	)
 
 	c.idleTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "idle_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "idle_seconds_total"),
 		"Seconds that the disk was idle (PhysicalDisk.PercentIdleTime)",
 		[]string{"disk"},
 		nil,
 	)
 
 	c.splitIOs = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "split_ios_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "split_ios_total"),
 		"The number of I/Os to the disk were split into multiple I/Os (PhysicalDisk.SplitIOPerSec)",
 		[]string{"disk"},
 		nil,
 	)
 
 	c.readLatency = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "read_latency_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "read_latency_seconds_total"),
 		"Shows the average time, in seconds, of a read operation from the disk (PhysicalDisk.AvgDiskSecPerRead)",
 		[]string{"disk"},
 		nil,
 	)
 
 	c.writeLatency = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "write_latency_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "write_latency_seconds_total"),
 		"Shows the average time, in seconds, of a write operation to the disk (PhysicalDisk.AvgDiskSecPerWrite)",
 		[]string{"disk"},
 		nil,
 	)
 
 	c.readWriteLatency = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "read_write_latency_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "read_write_latency_seconds_total"),
 		"Shows the time, in seconds, of the average disk transfer (PhysicalDisk.AvgDiskSecPerTransfer)",
 		[]string{"disk"},
 		nil,
@@ -203,7 +203,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ctx, logger, ch); err != nil {
 		logger.Error("failed collecting physical_disk metrics",
@@ -235,7 +235,7 @@ type PhysicalDisk struct {
 	AvgDiskSecPerTransfer  float64 `perflib:"Avg. Disk sec/Transfer"`
 }
 
-func (c *Collector) collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var dst []PhysicalDisk

internal/collector/printer/printer.go

@@ -10,7 +10,7 @@ import (
 	"strings"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -34,8 +34,8 @@ type Config struct {
 }
 
 var ConfigDefaults = Config{
-	PrinterInclude: types2.RegExpAny,
+	PrinterInclude: types.RegExpAny,
-	PrinterExclude: types2.RegExpEmpty,
+	PrinterExclude: types.RegExpEmpty,
 }
 
 type Collector struct {
@@ -115,19 +115,19 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	c.wmiClient = wmiClient
 
 	c.printerJobStatus = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "job_status"),
+		prometheus.BuildFQName(types.Namespace, Name, "job_status"),
 		"A counter of printer jobs by status",
 		[]string{"printer", "status"},
 		nil,
 	)
 	c.printerStatus = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "status"),
+		prometheus.BuildFQName(types.Namespace, Name, "status"),
 		"Printer status",
 		[]string{"printer", "status"},
 		nil,
 	)
 	c.printerJobCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "job_count"),
+		prometheus.BuildFQName(types.Namespace, Name, "job_count"),
 		"Number of jobs processed by the printer since the last reset",
 		[]string{"printer"},
 		nil,
@@ -154,7 +154,7 @@ type wmiPrintJob struct {
 	Status string
 }
 
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collectPrinterStatus(ch); err != nil {
 		logger.Error("failed to collect printer status metrics",

internal/collector/process/process.go

@@ -13,7 +13,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 	"golang.org/x/sys/windows"
@@ -28,8 +28,8 @@ type Config struct {
 }
 
 var ConfigDefaults = Config{
-	ProcessInclude:      types2.RegExpAny,
+	ProcessInclude:      types.RegExpAny,
-	ProcessExclude:      types2.RegExpEmpty,
+	ProcessExclude:      types.RegExpEmpty,
 	EnableWorkerProcess: false,
 }
 
@@ -144,98 +144,98 @@ func (c *Collector) Build(logger *slog.Logger, wmiClient *wmi.Client) error {
 	}
 
 	c.info = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "info"),
+		prometheus.BuildFQName(types.Namespace, Name, "info"),
 		"Process information.",
 		[]string{"process", "process_id", "creating_process_id", "process_group_id", "owner", "cmdline"},
 		nil,
 	)
 
 	c.startTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "start_time"),
+		prometheus.BuildFQName(types.Namespace, Name, "start_time"),
 		"Time of process start.",
 		[]string{"process", "process_id"},
 		nil,
 	)
 	c.cpuTimeTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cpu_time_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cpu_time_total"),
 		"Returns elapsed time that all of the threads of this process used the processor to execute instructions by mode (privileged, user).",
 		[]string{"process", "process_id", "mode"},
 		nil,
 	)
 	c.handleCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "handles"),
+		prometheus.BuildFQName(types.Namespace, Name, "handles"),
 		"Total number of handles the process has open. This number is the sum of the handles currently open by each thread in the process.",
 		[]string{"process", "process_id"},
 		nil,
 	)
 	c.ioBytesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "io_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "io_bytes_total"),
 		"Bytes issued to I/O operations in different modes (read, write, other).",
 		[]string{"process", "process_id", "mode"},
 		nil,
 	)
 	c.ioOperationsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "io_operations_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "io_operations_total"),
 		"I/O operations issued in different modes (read, write, other).",
 		[]string{"process", "process_id", "mode"},
 		nil,
 	)
 	c.pageFaultsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "page_faults_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "page_faults_total"),
 		"Page faults by the threads executing in this process.",
 		[]string{"process", "process_id"},
 		nil,
 	)
 	c.pageFileBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "page_file_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "page_file_bytes"),
 		"Current number of bytes this process has used in the paging file(s).",
 		[]string{"process", "process_id"},
 		nil,
 	)
 	c.poolBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pool_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "pool_bytes"),
 		"Pool Bytes is the last observed number of bytes in the paged or nonpaged pool.",
 		[]string{"process", "process_id", "pool"},
 		nil,
 	)
 	c.priorityBase = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "priority_base"),
+		prometheus.BuildFQName(types.Namespace, Name, "priority_base"),
 		"Current base priority of this process. Threads within a process can raise and lower their own base priority relative to the process base priority of the process.",
 		[]string{"process", "process_id"},
 		nil,
 	)
 	c.privateBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "private_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "private_bytes"),
 		"Current number of bytes this process has allocated that cannot be shared with other processes.",
 		[]string{"process", "process_id"},
 		nil,
 	)
 	c.threadCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "threads"),
+		prometheus.BuildFQName(types.Namespace, Name, "threads"),
 		"Number of threads currently active in this process.",
 		[]string{"process", "process_id"},
 		nil,
 	)
 	c.virtualBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "virtual_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "virtual_bytes"),
 		"Current size, in bytes, of the virtual address space that the process is using.",
 		[]string{"process", "process_id"},
 		nil,
 	)
 	c.workingSetPrivate = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "working_set_private_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "working_set_private_bytes"),
 		"Size of the working set, in bytes, that is use for this process only and not shared nor shareable by other processes.",
 		[]string{"process", "process_id"},
 		nil,
 	)
 	c.workingSetPeak = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "working_set_peak_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "working_set_peak_bytes"),
 		"Maximum size, in bytes, of the Working Set of this process at any point in time. The Working Set is the set of memory pages touched recently by the threads in the process.",
 		[]string{"process", "process_id"},
 		nil,
 	)
 	c.workingSet = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "working_set_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "working_set_bytes"),
 		"Maximum number of bytes in the working set of this process at any point in time. The working set is the set of memory pages touched recently by the threads in the process.",
 		[]string{"process", "process_id"},
 		nil,
@@ -283,7 +283,7 @@ type WorkerProcess struct {
 	ProcessId   uint64
 }
 
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	data := make([]perflibProcess, 0)
 

internal/collector/remote_fx/remote_fx.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus-community/windows_exporter/internal/utils"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
@@ -84,79 +84,79 @@ func (c *Collector) Close(_ *slog.Logger) error {
 func (c *Collector) Build(*slog.Logger, *wmi.Client) error {
 	// net
 	c.baseTCPRTT = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_base_tcp_rtt_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_base_tcp_rtt_seconds"),
 		"Base TCP round-trip time (RTT) detected in seconds",
 		[]string{"session_name"},
 		nil,
 	)
 	c.baseUDPRTT = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_base_udp_rtt_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_base_udp_rtt_seconds"),
 		"Base UDP round-trip time (RTT) detected in seconds.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.currentTCPBandwidth = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_current_tcp_bandwidth"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_current_tcp_bandwidth"),
 		"TCP Bandwidth detected in bytes per second.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.currentTCPRTT = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_current_tcp_rtt_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_current_tcp_rtt_seconds"),
 		"Average TCP round-trip time (RTT) detected in seconds.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.currentUDPBandwidth = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_current_udp_bandwidth"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_current_udp_bandwidth"),
 		"UDP Bandwidth detected in bytes per second.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.currentUDPRTT = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_current_udp_rtt_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_current_udp_rtt_seconds"),
 		"Average UDP round-trip time (RTT) detected in seconds.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.totalReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_received_bytes_total"),
 		"(TotalReceivedBytes)",
 		[]string{"session_name"},
 		nil,
 	)
 	c.totalSentBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_sent_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_sent_bytes_total"),
 		"(TotalSentBytes)",
 		[]string{"session_name"},
 		nil,
 	)
 	c.udpPacketsReceivedPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_udp_packets_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_udp_packets_received_total"),
 		"Rate in packets per second at which packets are received over UDP.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.udpPacketsSentPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_udp_packets_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_udp_packets_sent_total"),
 		"Rate in packets per second at which packets are sent over UDP.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.fecRate = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_fec_rate"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_fec_rate"),
 		"Forward Error Correction (FEC) percentage",
 		[]string{"session_name"},
 		nil,
 	)
 	c.lossRate = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_loss_rate"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_loss_rate"),
 		"Loss percentage",
 		[]string{"session_name"},
 		nil,
 	)
 	c.retransmissionRate = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "net_retransmission_rate"),
+		prometheus.BuildFQName(types.Namespace, Name, "net_retransmission_rate"),
 		"Percentage of packets that have been retransmitted",
 		[]string{"session_name"},
 		nil,
@@ -164,43 +164,43 @@ func (c *Collector) Build(*slog.Logger, *wmi.Client) error {
 
 	// gfx
 	c.averageEncodingTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "gfx_average_encoding_time_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "gfx_average_encoding_time_seconds"),
 		"Average frame encoding time in seconds",
 		[]string{"session_name"},
 		nil,
 	)
 	c.frameQuality = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "gfx_frame_quality"),
+		prometheus.BuildFQName(types.Namespace, Name, "gfx_frame_quality"),
 		"Quality of the output frame expressed as a percentage of the quality of the source frame.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.framesSkippedPerSecondInsufficientResources = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "gfx_frames_skipped_insufficient_resource_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "gfx_frames_skipped_insufficient_resource_total"),
 		"Number of frames skipped per second due to insufficient client resources.",
 		[]string{"session_name", "resource"},
 		nil,
 	)
 	c.graphicsCompressionRatio = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "gfx_graphics_compression_ratio"),
+		prometheus.BuildFQName(types.Namespace, Name, "gfx_graphics_compression_ratio"),
 		"Ratio of the number of bytes encoded to the number of bytes input.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.inputFramesPerSecond = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "gfx_input_frames_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "gfx_input_frames_total"),
 		"Number of sources frames provided as input to RemoteFX graphics per second.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.outputFramesPerSecond = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "gfx_output_frames_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "gfx_output_frames_total"),
 		"Number of frames sent to the client per second.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.sourceFramesPerSecond = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "gfx_source_frames_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "gfx_source_frames_total"),
 		"Number of frames composed by the source (DWM) per second.",
 		[]string{"session_name"},
 		nil,
@@ -211,7 +211,7 @@ func (c *Collector) Build(*slog.Logger, *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collectRemoteFXNetworkCount(ctx, logger, ch); err != nil {
 		logger.Error("failed collecting terminal services session count metrics",
@@ -249,7 +249,7 @@ type perflibRemoteFxNetwork struct {
 	RetransmissionRate       float64 `perflib:"Percentage of packets that have been retransmitted"`
 }
 
-func (c *Collector) collectRemoteFXNetworkCount(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectRemoteFXNetworkCount(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	dst := make([]perflibRemoteFxNetwork, 0)
 
@@ -362,7 +362,7 @@ type perflibRemoteFxGraphics struct {
 	SourceFramesPerSecond                              float64 `perflib:"Source Frames/Second"`
 }
 
-func (c *Collector) collectRemoteFXGraphicsCounters(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectRemoteFXGraphicsCounters(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	dst := make([]perflibRemoteFxGraphics, 0)
 

internal/collector/scheduled_task/scheduled_task.go

@@ -13,7 +13,7 @@ import (
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/go-ole/go-ole"
 	"github.com/go-ole/go-ole/oleutil"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -26,8 +26,8 @@ type Config struct {
 }
 
 var ConfigDefaults = Config{
-	TaskExclude: types2.RegExpEmpty,
+	TaskExclude: types.RegExpEmpty,
-	TaskInclude: types2.RegExpAny,
+	TaskInclude: types.RegExpAny,
 }
 
 type Collector struct {
@@ -160,21 +160,21 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	}
 
 	c.lastResult = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "last_result"),
+		prometheus.BuildFQName(types.Namespace, Name, "last_result"),
 		"The result that was returned the last time the registered task was run",
 		[]string{"task"},
 		nil,
 	)
 
 	c.missedRuns = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "missed_runs"),
+		prometheus.BuildFQName(types.Namespace, Name, "missed_runs"),
 		"The number of times the registered task missed a scheduled run",
 		[]string{"task"},
 		nil,
 	)
 
 	c.state = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "state"),
+		prometheus.BuildFQName(types.Namespace, Name, "state"),
 		"The current state of a scheduled task",
 		[]string{"task", "state"},
 		nil,
@@ -183,7 +183,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	return nil
 }
 
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ch); err != nil {
 		logger.Error("failed collecting user metrics",

internal/collector/service/service.go

@@ -11,7 +11,7 @@ import (
 	"unsafe"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 	"golang.org/x/sys/windows"
@@ -26,8 +26,8 @@ type Config struct {
 }
 
 var ConfigDefaults = Config{
-	ServiceInclude: types2.RegExpAny,
+	ServiceInclude: types.RegExpAny,
-	ServiceExclude: types2.RegExpEmpty,
+	ServiceExclude: types.RegExpEmpty,
 }
 
 // A Collector is a Prometheus Collector for service metrics.
@@ -114,25 +114,25 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 	}
 
 	c.info = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "info"),
+		prometheus.BuildFQName(types.Namespace, Name, "info"),
 		"A metric with a constant '1' value labeled with service information",
 		[]string{"name", "display_name", "run_as", "path_name"},
 		nil,
 	)
 	c.state = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "state"),
+		prometheus.BuildFQName(types.Namespace, Name, "state"),
 		"The state of the service (State)",
 		[]string{"name", "state"},
 		nil,
 	)
 	c.startMode = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "start_mode"),
+		prometheus.BuildFQName(types.Namespace, Name, "start_mode"),
 		"The start mode of the service (StartMode)",
 		[]string{"name", "start_mode"},
 		nil,
 	)
 	c.processID = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "process"),
+		prometheus.BuildFQName(types.Namespace, Name, "process"),
 		"Process of started service. The value is the creation time of the process as a unix timestamp.",
 		[]string{"name", "process_id"},
 		nil,
@@ -161,7 +161,7 @@ func (c *Collector) Close(logger *slog.Logger) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	if err := c.collect(logger, ch); err != nil {

internal/collector/smb/smb.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -60,7 +60,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	// desc creates a new prometheus description
 	desc := func(metricName string, description string, labels ...string) *prometheus.Desc {
 		return prometheus.NewDesc(
-			prometheus.BuildFQName(types2.Namespace, "smb", metricName),
+			prometheus.BuildFQName(types.Namespace, "smb", metricName),
 			description,
 			labels,
 			nil,
@@ -74,7 +74,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 }
 
 // Collect collects smb metrics and sends them to prometheus.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collectServerShares(ctx, logger, ch); err != nil {
 		logger.Error("failed to collect server share metrics",
@@ -95,7 +95,7 @@ type perflibServerShares struct {
 	TreeConnectCount     float64 `perflib:"Tree Connect Count"`
 }
 
-func (c *Collector) collectServerShares(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectServerShares(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var data []perflibServerShares

internal/collector/smbclient/smbclient.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -82,7 +82,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	// desc creates a new prometheus description
 	desc := func(metricName string, description string, labels []string) *prometheus.Desc {
 		return prometheus.NewDesc(
-			prometheus.BuildFQName(types2.Namespace, "smbclient", metricName),
+			prometheus.BuildFQName(types.Namespace, "smbclient", metricName),
 			description,
 			labels,
 			nil,
@@ -178,7 +178,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 }
 
 // Collect collects smb client metrics and sends them to prometheus.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collectClientShares(ctx, logger, ch); err != nil {
 		logger.Error("Error in ClientShares",
@@ -218,7 +218,7 @@ type perflibClientShares struct {
 	WriteRequestsPerSec                        float64 `perflib:"Write Requests/sec"`
 }
 
-func (c *Collector) collectClientShares(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectClientShares(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var data []perflibClientShares

internal/collector/smtp/smtp.go

@@ -9,7 +9,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -22,8 +22,8 @@ type Config struct {
 }
 
 var ConfigDefaults = Config{
-	ServerInclude: types2.RegExpAny,
+	ServerInclude: types.RegExpAny,
-	ServerExclude: types2.RegExpEmpty,
+	ServerExclude: types.RegExpEmpty,
 }
 
 type Collector struct {
@@ -147,253 +147,253 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 	logger.Info("smtp collector is in an experimental state! Metrics for this collector have not been tested.")
 
 	c.badMailedMessagesBadPickupFileTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "badmailed_messages_bad_pickup_file_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "badmailed_messages_bad_pickup_file_total"),
 		"Total number of malformed pickup messages sent to badmail",
 		[]string{"site"},
 		nil,
 	)
 	c.badMailedMessagesGeneralFailureTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "badmailed_messages_general_failure_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "badmailed_messages_general_failure_total"),
 		"Total number of messages sent to badmail for reasons not associated with a specific counter",
 		[]string{"site"},
 		nil,
 	)
 	c.badMailedMessagesHopCountExceededTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "badmailed_messages_hop_count_exceeded_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "badmailed_messages_hop_count_exceeded_total"),
 		"Total number of messages sent to badmail because they had exceeded the maximum hop count",
 		[]string{"site"},
 		nil,
 	)
 	c.badMailedMessagesNDROfDSNTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "badmailed_messages_ndr_of_dns_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "badmailed_messages_ndr_of_dns_total"),
 		"Total number of Delivery Status Notifications sent to badmail because they could not be delivered",
 		[]string{"site"},
 		nil,
 	)
 	c.badMailedMessagesNoRecipientsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "badmailed_messages_no_recipients_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "badmailed_messages_no_recipients_total"),
 		"Total number of messages sent to badmail because they had no recipients",
 		[]string{"site"},
 		nil,
 	)
 	c.badMailedMessagesTriggeredViaEventTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "badmailed_messages_triggered_via_event_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "badmailed_messages_triggered_via_event_total"),
 		"Total number of messages sent to badmail at the request of a server event sink",
 		[]string{"site"},
 		nil,
 	)
 	c.bytesSentTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "bytes_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "bytes_sent_total"),
 		"Total number of bytes sent",
 		[]string{"site"},
 		nil,
 	)
 	c.bytesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "bytes_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "bytes_received_total"),
 		"Total number of bytes received",
 		[]string{"site"},
 		nil,
 	)
 	c.categorizerQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "categorizer_queue_length"),
+		prometheus.BuildFQName(types.Namespace, Name, "categorizer_queue_length"),
 		"Number of messages in the categorizer queue",
 		[]string{"site"},
 		nil,
 	)
 	c.connectionErrorsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_errors_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_errors_total"),
 		"Total number of connection errors",
 		[]string{"site"},
 		nil,
 	)
 	c.currentMessagesInLocalDelivery = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "current_messages_in_local_delivery"),
+		prometheus.BuildFQName(types.Namespace, Name, "current_messages_in_local_delivery"),
 		"Number of messages that are currently being processed by a server event sink for local delivery",
 		[]string{"site"},
 		nil,
 	)
 	c.directoryDropsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "directory_drops_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "directory_drops_total"),
 		"Total number of messages placed in a drop directory",
 		[]string{"site"},
 		nil,
 	)
 	c.dsnFailuresTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "dsn_failures_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "dsn_failures_total"),
 		"Total number of failed DSN generation attempts",
 		[]string{"site"},
 		nil,
 	)
 	c.dnsQueriesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "dns_queries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "dns_queries_total"),
 		"Total number of DNS lookups",
 		[]string{"site"},
 		nil,
 	)
 	c.etrnMessagesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "etrn_messages_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "etrn_messages_total"),
 		"Total number of ETRN messages received by the server",
 		[]string{"site"},
 		nil,
 	)
 	c.inboundConnectionsCurrent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "inbound_connections_current"),
+		prometheus.BuildFQName(types.Namespace, Name, "inbound_connections_current"),
 		"Total number of connections currently inbound",
 		[]string{"site"},
 		nil,
 	)
 	c.inboundConnectionsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "inbound_connections_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "inbound_connections_total"),
 		"Total number of inbound connections received",
 		[]string{"site"},
 		nil,
 	)
 	c.localQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "local_queue_length"),
+		prometheus.BuildFQName(types.Namespace, Name, "local_queue_length"),
 		"Number of messages in the local queue",
 		[]string{"site"},
 		nil,
 	)
 	c.localRetryQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "local_retry_queue_length"),
+		prometheus.BuildFQName(types.Namespace, Name, "local_retry_queue_length"),
 		"Number of messages in the local retry queue",
 		[]string{"site"},
 		nil,
 	)
 	c.mailFilesOpen = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mail_files_open"),
+		prometheus.BuildFQName(types.Namespace, Name, "mail_files_open"),
 		"Number of handles to open mail files",
 		[]string{"site"},
 		nil,
 	)
 	c.messageBytesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "message_bytes_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "message_bytes_received_total"),
 		"Total number of bytes received in messages",
 		[]string{"site"},
 		nil,
 	)
 	c.messageBytesSentTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "message_bytes_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "message_bytes_sent_total"),
 		"Total number of bytes sent in messages",
 		[]string{"site"},
 		nil,
 	)
 	c.messageDeliveryRetriesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "message_delivery_retries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "message_delivery_retries_total"),
 		"Total number of local deliveries that were retried",
 		[]string{"site"},
 		nil,
 	)
 	c.messageSendRetriesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "message_send_retries_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "message_send_retries_total"),
 		"Total number of outbound message sends that were retried",
 		[]string{"site"},
 		nil,
 	)
 	c.messagesCurrentlyUndeliverable = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "messages_currently_undeliverable"),
+		prometheus.BuildFQName(types.Namespace, Name, "messages_currently_undeliverable"),
 		"Number of messages that have been reported as currently undeliverable by routing",
 		[]string{"site"},
 		nil,
 	)
 	c.messagesDeliveredTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "messages_delivered_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "messages_delivered_total"),
 		"Total number of messages delivered to local mailboxes",
 		[]string{"site"},
 		nil,
 	)
 	c.messagesPendingRouting = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "messages_pending_routing"),
+		prometheus.BuildFQName(types.Namespace, Name, "messages_pending_routing"),
 		"Number of messages that have been categorized but not routed",
 		[]string{"site"},
 		nil,
 	)
 	c.messagesReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "messages_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "messages_received_total"),
 		"Total number of inbound messages accepted",
 		[]string{"site"},
 		nil,
 	)
 	c.messagesRefusedForAddressObjectsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "messages_refused_for_address_objects_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "messages_refused_for_address_objects_total"),
 		"Total number of messages refused due to no address objects",
 		[]string{"site"},
 		nil,
 	)
 	c.messagesRefusedForMailObjectsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "messages_refused_for_mail_objects_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "messages_refused_for_mail_objects_total"),
 		"Total number of messages refused due to no mail objects",
 		[]string{"site"},
 		nil,
 	)
 	c.messagesRefusedForSizeTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "messages_refused_for_size_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "messages_refused_for_size_total"),
 		"Total number of messages rejected because they were too big",
 		[]string{"site"},
 		nil,
 	)
 	c.messagesSentTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "messages_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "messages_sent_total"),
 		"Total number of outbound messages sent",
 		[]string{"site"},
 		nil,
 	)
 	c.messagesSubmittedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "messages_submitted_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "messages_submitted_total"),
 		"Total number of messages submitted to queuing for delivery",
 		[]string{"site"},
 		nil,
 	)
 	c.ndrsGeneratedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ndrs_generated_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "ndrs_generated_total"),
 		"Total number of non-delivery reports that have been generated",
 		[]string{"site"},
 		nil,
 	)
 	c.outboundConnectionsCurrent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "outbound_connections_current"),
+		prometheus.BuildFQName(types.Namespace, Name, "outbound_connections_current"),
 		"Number of connections currently outbound",
 		[]string{"site"},
 		nil,
 	)
 	c.outboundConnectionsRefusedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "outbound_connections_refused_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "outbound_connections_refused_total"),
 		"Total number of connection attempts refused by remote sites",
 		[]string{"site"},
 		nil,
 	)
 	c.outboundConnectionsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "outbound_connections_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "outbound_connections_total"),
 		"Total number of outbound connections attempted",
 		[]string{"site"},
 		nil,
 	)
 	c.pickupDirectoryMessagesRetrievedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pickup_directory_messages_retrieved_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "pickup_directory_messages_retrieved_total"),
 		"Total number of messages retrieved from the mail pick-up directory",
 		[]string{"site"},
 		nil,
 	)
 	c.queueFilesOpen = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "queue_files_open"),
+		prometheus.BuildFQName(types.Namespace, Name, "queue_files_open"),
 		"Number of handles to open queue files",
 		[]string{"site"},
 		nil,
 	)
 	c.remoteQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "remote_queue_length"),
+		prometheus.BuildFQName(types.Namespace, Name, "remote_queue_length"),
 		"Number of messages in the remote queue",
 		[]string{"site"},
 		nil,
 	)
 	c.remoteRetryQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "remote_retry_queue_length"),
+		prometheus.BuildFQName(types.Namespace, Name, "remote_retry_queue_length"),
 		"Number of messages in the retry queue for remote delivery",
 		[]string{"site"},
 		nil,
 	)
 	c.routingTableLookupsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "routing_table_lookups_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "routing_table_lookups_total"),
 		"Total number of routing table lookups",
 		[]string{"site"},
 		nil,
@@ -404,7 +404,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ctx, logger, ch); err != nil {
 		logger.Error("failed collecting smtp metrics",
@@ -465,7 +465,7 @@ type PerflibSMTPServer struct {
 	RoutingTableLookupsTotal                float64 `perflib:"Routing Table Lookups Total"`
 }
 
-func (c *Collector) collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var dst []PerflibSMTPServer

internal/collector/system/system.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -63,50 +63,50 @@ func (c *Collector) Close(_ *slog.Logger) error {
 
 func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	c.contextSwitchesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "context_switches_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "context_switches_total"),
 		"Total number of context switches (WMI source: PerfOS_System.ContextSwitchesPersec)",
 		nil,
 		nil,
 	)
 	c.exceptionDispatchesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "exception_dispatches_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "exception_dispatches_total"),
 		"Total number of exceptions dispatched (WMI source: PerfOS_System.ExceptionDispatchesPersec)",
 		nil,
 		nil,
 	)
 	c.processes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "processes"),
+		prometheus.BuildFQName(types.Namespace, Name, "processes"),
 		"Current number of processes (WMI source: PerfOS_System.Processes)",
 		nil,
 		nil,
 	)
 	c.processesLimit = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "processes_limit"),
+		prometheus.BuildFQName(types.Namespace, Name, "processes_limit"),
 		"Maximum number of processes.",
 		nil,
 		nil,
 	)
 
 	c.processorQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "processor_queue_length"),
+		prometheus.BuildFQName(types.Namespace, Name, "processor_queue_length"),
 		"Length of processor queue (WMI source: PerfOS_System.ProcessorQueueLength)",
 		nil,
 		nil,
 	)
 	c.systemCallsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "system_calls_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "system_calls_total"),
 		"Total number of system calls (WMI source: PerfOS_System.SystemCallsPersec)",
 		nil,
 		nil,
 	)
 	c.systemUpTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "system_up_time"),
+		prometheus.BuildFQName(types.Namespace, Name, "system_up_time"),
 		"System boot time (WMI source: PerfOS_System.SystemUpTime)",
 		nil,
 		nil,
 	)
 	c.threads = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "threads"),
+		prometheus.BuildFQName(types.Namespace, Name, "threads"),
 		"Current number of threads (WMI source: PerfOS_System.Threads)",
 		nil,
 		nil,
@@ -117,7 +117,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ctx, logger, ch); err != nil {
 		logger.Error("failed collecting system metrics",
@@ -142,7 +142,7 @@ type system struct {
 	Threads                   float64 `perflib:"Threads"`
 }
 
-func (c *Collector) collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var dst []system

internal/collector/tcp/tcp.go

@@ -9,9 +9,9 @@ import (
 	"strings"
 
 	"github.com/alecthomas/kingpin/v2"
-	iphlpapi2 "github.com/prometheus-community/windows_exporter/internal/headers/iphlpapi"
+	"github.com/prometheus-community/windows_exporter/internal/headers/iphlpapi"
 	"github.com/prometheus-community/windows_exporter/internal/perfdata"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 	"golang.org/x/sys/windows"
@@ -125,61 +125,61 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	}
 
 	c.connectionFailures = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_failures_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_failures_total"),
 		"(TCP.ConnectionFailures)",
 		[]string{"af"},
 		nil,
 	)
 	c.connectionsActive = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connections_active_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connections_active_total"),
 		"(TCP.ConnectionsActive)",
 		[]string{"af"},
 		nil,
 	)
 	c.connectionsEstablished = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connections_established"),
+		prometheus.BuildFQName(types.Namespace, Name, "connections_established"),
 		"(TCP.ConnectionsEstablished)",
 		[]string{"af"},
 		nil,
 	)
 	c.connectionsPassive = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connections_passive_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connections_passive_total"),
 		"(TCP.ConnectionsPassive)",
 		[]string{"af"},
 		nil,
 	)
 	c.connectionsReset = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connections_reset_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connections_reset_total"),
 		"(TCP.ConnectionsReset)",
 		[]string{"af"},
 		nil,
 	)
 	c.segmentsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "segments_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "segments_total"),
 		"(TCP.SegmentsTotal)",
 		[]string{"af"},
 		nil,
 	)
 	c.segmentsReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "segments_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "segments_received_total"),
 		"(TCP.SegmentsReceivedTotal)",
 		[]string{"af"},
 		nil,
 	)
 	c.segmentsRetransmittedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "segments_retransmitted_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "segments_retransmitted_total"),
 		"(TCP.SegmentsRetransmittedTotal)",
 		[]string{"af"},
 		nil,
 	)
 	c.segmentsSentTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "segments_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "segments_sent_total"),
 		"(TCP.SegmentsSentTotal)",
 		[]string{"af"},
 		nil,
 	)
 	c.connectionsStateCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connections_state_count"),
+		prometheus.BuildFQName(types.Namespace, Name, "connections_state_count"),
 		"Number of TCP connections by state and address family",
 		[]string{"af", "state"}, nil,
 	)
@@ -189,7 +189,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	if slices.Contains(c.config.CollectorsEnabled, "metrics") {
@@ -291,14 +291,14 @@ func (c *Collector) writeTCPCounters(ch chan<- prometheus.Metric, metrics map[st
 }
 
 func (c *Collector) collectConnectionsState(ch chan<- prometheus.Metric) error {
-	stateCounts, err := iphlpapi2.GetTCPConnectionStates(windows.AF_INET)
+	stateCounts, err := iphlpapi.GetTCPConnectionStates(windows.AF_INET)
 	if err != nil {
 		return fmt.Errorf("failed to collect TCP connection states for %s: %w", "ipv4", err)
 	}
 
 	c.sendTCPStateMetrics(ch, stateCounts, "ipv4")
 
-	stateCounts, err = iphlpapi2.GetTCPConnectionStates(windows.AF_INET6)
+	stateCounts, err = iphlpapi.GetTCPConnectionStates(windows.AF_INET6)
 	if err != nil {
 		return fmt.Errorf("failed to collect TCP6 connection states for %s: %w", "ipv6", err)
 	}
@@ -308,7 +308,7 @@ func (c *Collector) collectConnectionsState(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
-func (c *Collector) sendTCPStateMetrics(ch chan<- prometheus.Metric, stateCounts map[iphlpapi2.MIB_TCP_STATE]uint32, af string) {
+func (c *Collector) sendTCPStateMetrics(ch chan<- prometheus.Metric, stateCounts map[iphlpapi.MIB_TCP_STATE]uint32, af string) {
 	for state, count := range stateCounts {
 		ch <- prometheus.MustNewConstMetric(
 			c.connectionsStateCount,

internal/collector/teradici_pcoip/teradici_pcoip.go

@@ -7,7 +7,7 @@ import (
 	"log/slog"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -111,227 +111,227 @@ func (c *Collector) Build(logger *slog.Logger, wmiClient *wmi.Client) error {
 	c.wmiClient = wmiClient
 
 	c.audioBytesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "audio_bytes_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "audio_bytes_received_total"),
 		"(AudioBytesReceived)",
 		nil,
 		nil,
 	)
 	c.audioBytesSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "audio_bytes_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "audio_bytes_sent_total"),
 		"(AudioBytesSent)",
 		nil,
 		nil,
 	)
 	c.audioRXBWKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "audio_rx_bw_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "audio_rx_bw_KBit_persec"),
 		"(AudioRXBWKBitPerSec)",
 		nil,
 		nil,
 	)
 	c.audioTXBWKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "audio_tx_bw_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "audio_tx_bw_KBit_persec"),
 		"(AudioTXBWKBitPerSec)",
 		nil,
 		nil,
 	)
 	c.audioTXBWLimitKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "audio_tx_bw_limit_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "audio_tx_bw_limit_KBit_persec"),
 		"(AudioTXBWLimitKBitPerSec)",
 		nil,
 		nil,
 	)
 
 	c.bytesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "bytes_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "bytes_received_total"),
 		"(BytesReceived)",
 		nil,
 		nil,
 	)
 	c.bytesSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "bytes_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "bytes_sent_total"),
 		"(BytesSent)",
 		nil,
 		nil,
 	)
 	c.packetsReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "packets_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "packets_received_total"),
 		"(PacketsReceived)",
 		nil,
 		nil,
 	)
 	c.packetsSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "packets_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "packets_sent_total"),
 		"(PacketsSent)",
 		nil,
 		nil,
 	)
 	c.rxPacketsLost = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "rx_packets_lost_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "rx_packets_lost_total"),
 		"(RXPacketsLost)",
 		nil,
 		nil,
 	)
 	c.sessionDurationSeconds = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_duration_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_duration_seconds_total"),
 		"(SessionDurationSeconds)",
 		nil,
 		nil,
 	)
 	c.txPacketsLost = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "tx_packets_lost_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "tx_packets_lost_total"),
 		"(TXPacketsLost)",
 		nil,
 		nil,
 	)
 
 	c.imagingActiveMinimumQuality = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_active_min_quality"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_active_min_quality"),
 		"(ImagingActiveMinimumQuality)",
 		nil,
 		nil,
 	)
 	c.imagingApex2800Offload = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_apex2800_offload"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_apex2800_offload"),
 		"(ImagingApex2800Offload)",
 		nil,
 		nil,
 	)
 	c.imagingBytesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_bytes_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_bytes_received_total"),
 		"(ImagingBytesReceived)",
 		nil,
 		nil,
 	)
 	c.imagingBytesSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_bytes_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_bytes_sent_total"),
 		"(ImagingBytesSent)",
 		nil,
 		nil,
 	)
 	c.imagingDecoderCapabilityKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_decoder_capability_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_decoder_capability_KBit_persec"),
 		"(ImagingDecoderCapabilityKBitPerSec)",
 		nil,
 		nil,
 	)
 	c.imagingEncodedFramesPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_encoded_frames_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_encoded_frames_persec"),
 		"(ImagingEncodedFramesPerSec)",
 		nil,
 		nil,
 	)
 	c.imagingMegapixelPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_megapixel_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_megapixel_persec"),
 		"(ImagingMegapixelPerSec)",
 		nil,
 		nil,
 	)
 	c.imagingNegativeAcknowledgements = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_negative_acks_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_negative_acks_total"),
 		"(ImagingNegativeAcknowledgements)",
 		nil,
 		nil,
 	)
 	c.imagingRXBWKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_rx_bw_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_rx_bw_KBit_persec"),
 		"(ImagingRXBWKBitPerSec)",
 		nil,
 		nil,
 	)
 	c.imagingSVGAdevTapframesPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_svga_devtap_frames_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_svga_devtap_frames_persec"),
 		"(ImagingSVGAdevTapframesPerSec)",
 		nil,
 		nil,
 	)
 	c.imagingTXBWKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_tx_bw_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_tx_bw_KBit_persec"),
 		"(ImagingTXBWKBitPerSec)",
 		nil,
 		nil,
 	)
 
 	c.RoundTripLatencyms = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "round_trip_latency_ms"),
+		prometheus.BuildFQName(types.Namespace, Name, "round_trip_latency_ms"),
 		"(RoundTripLatencyms)",
 		nil,
 		nil,
 	)
 	c.rxBWKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "rx_bw_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "rx_bw_KBit_persec"),
 		"(RXBWKBitPerSec)",
 		nil,
 		nil,
 	)
 	c.rxBWPeakKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "rx_bw_peak_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "rx_bw_peak_KBit_persec"),
 		"(RXBWPeakKBitPerSec)",
 		nil,
 		nil,
 	)
 	c.rxPacketLossPercent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "rx_packet_loss_percent"),
+		prometheus.BuildFQName(types.Namespace, Name, "rx_packet_loss_percent"),
 		"(RXPacketLossPercent)",
 		nil,
 		nil,
 	)
 	c.rxPacketLossPercentBase = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "rx_packet_loss_percent_base"),
+		prometheus.BuildFQName(types.Namespace, Name, "rx_packet_loss_percent_base"),
 		"(RXPacketLossPercent_Base)",
 		nil,
 		nil,
 	)
 	c.txBWActiveLimitKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "tx_bw_active_limit_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "tx_bw_active_limit_KBit_persec"),
 		"(TXBWActiveLimitKBitPerSec)",
 		nil,
 		nil,
 	)
 	c.txBWKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "tx_bw_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "tx_bw_KBit_persec"),
 		"(TXBWKBitPerSec)",
 		nil,
 		nil,
 	)
 	c.txBWLimitKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "tx_bw_limit_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "tx_bw_limit_KBit_persec"),
 		"(TXBWLimitKBitPerSec)",
 		nil,
 		nil,
 	)
 	c.txPacketLossPercent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "tx_packet_loss_percent"),
+		prometheus.BuildFQName(types.Namespace, Name, "tx_packet_loss_percent"),
 		"(TXPacketLossPercent)",
 		nil,
 		nil,
 	)
 	c.txPacketLossPercentBase = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "tx_packet_loss_percent_base"),
+		prometheus.BuildFQName(types.Namespace, Name, "tx_packet_loss_percent_base"),
 		"(TXPacketLossPercent_Base)",
 		nil,
 		nil,
 	)
 
 	c.usbBytesReceived = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "usb_bytes_received_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "usb_bytes_received_total"),
 		"(USBBytesReceived)",
 		nil,
 		nil,
 	)
 	c.usbBytesSent = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "usb_bytes_sent_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "usb_bytes_sent_total"),
 		"(USBBytesSent)",
 		nil,
 		nil,
 	)
 	c.usbRXBWKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "usb_rx_bw_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "usb_rx_bw_KBit_persec"),
 		"(USBRXBWKBitPerSec)",
 		nil,
 		nil,
 	)
 	c.usbTXBWKBitPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "usb_tx_bw_KBit_persec"),
+		prometheus.BuildFQName(types.Namespace, Name, "usb_tx_bw_KBit_persec"),
 		"(USBTXBWKBitPerSec)",
 		nil,
 		nil,
@@ -342,7 +342,7 @@ func (c *Collector) Build(logger *slog.Logger, wmiClient *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collectAudio(ch); err != nil {
 		logger.Error("failed collecting teradici session audio metrics",

internal/collector/terminal_services/terminal_services.go

@@ -12,7 +12,7 @@ import (
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/headers/wtsapi32"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 	"golang.org/x/sys/windows"
@@ -118,91 +118,91 @@ func (c *Collector) Build(logger *slog.Logger, wmiClient *wmi.Client) error {
 	c.connectionBrokerEnabled = isConnectionBrokerServer(logger, wmiClient)
 
 	c.sessionInfo = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_info"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_info"),
 		"Terminal Services sessions info",
 		[]string{"session_name", "user", "host", "state", "id"},
 		nil,
 	)
 	c.connectionBrokerPerformance = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "connection_broker_performance_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "connection_broker_performance_total"),
 		"The total number of connections handled by the Connection Brokers since the service started.",
 		[]string{"connection"},
 		nil,
 	)
 	c.handleCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "handles"),
+		prometheus.BuildFQName(types.Namespace, Name, "handles"),
 		"Total number of handles currently opened by this process. This number is the sum of the handles currently opened by each thread in this process.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.pageFaultsPerSec = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "page_fault_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "page_fault_total"),
 		"Rate at which page faults occur in the threads executing in this process. A page fault occurs when a thread refers to a virtual memory page that is not in its working set in main memory. The page may not be retrieved from disk if it is on the standby list and therefore already in main memory. The page also may not be retrieved if it is in use by another process which shares the page.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.pageFileBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "page_file_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "page_file_bytes"),
 		"Current number of bytes this process has used in the paging file(s). Paging files are used to store pages of memory used by the process that are not contained in other files. Paging files are shared by all processes, and lack of space in paging files can prevent other processes from allocating memory.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.pageFileBytesPeak = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "page_file_bytes_peak"),
+		prometheus.BuildFQName(types.Namespace, Name, "page_file_bytes_peak"),
 		"Maximum number of bytes this process has used in the paging file(s). Paging files are used to store pages of memory used by the process that are not contained in other files. Paging files are shared by all processes, and lack of space in paging files can prevent other processes from allocating memory.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.percentCPUTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cpu_time_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cpu_time_seconds_total"),
 		"Total elapsed time that this process's threads have spent executing code.",
 		[]string{"mode", "session_name"},
 		nil,
 	)
 	c.poolNonPagedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pool_non_paged_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "pool_non_paged_bytes"),
 		"Number of bytes in the non-paged pool, an area of system memory (physical memory used by the operating system) for objects that cannot be written to disk, but must remain in physical memory as long as they are allocated. This property displays the last observed value only; it is not an average.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.poolPagedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pool_paged_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "pool_paged_bytes"),
 		"Number of bytes in the paged pool, an area of system memory (physical memory used by the operating system) for objects that can be written to disk when they are not being used. This property displays the last observed value only; it is not an average.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.privateBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "private_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "private_bytes"),
 		"Current number of bytes this process has allocated that cannot be shared with other processes.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.threadCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "threads"),
+		prometheus.BuildFQName(types.Namespace, Name, "threads"),
 		"Number of threads currently active in this process. An instruction is the basic unit of execution in a processor, and a thread is the object that executes instructions. Every running process has at least one thread.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.virtualBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "virtual_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "virtual_bytes"),
 		"Current size, in bytes, of the virtual address space the process is using. Use of virtual address space does not necessarily imply corresponding use of either disk or main memory pages. Virtual space is finite and, by using too much, the process can limit its ability to load libraries.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.virtualBytesPeak = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "virtual_bytes_peak"),
+		prometheus.BuildFQName(types.Namespace, Name, "virtual_bytes_peak"),
 		"Maximum number of bytes of virtual address space the process has used at any one time. Use of virtual address space does not necessarily imply corresponding use of either disk or main memory pages. Virtual space is finite and, by using too much, the process might limit its ability to load libraries.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.workingSet = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "working_set_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "working_set_bytes"),
 		"Current number of bytes in the working set of this process. The working set is the set of memory pages touched recently by the threads in the process. If free memory in the computer is above a threshold, pages are left in the working set of a process even if they are not in use. When free memory falls below a threshold, pages are trimmed from working sets. If they are needed, they are then soft-faulted back into the working set before they leave main memory.",
 		[]string{"session_name"},
 		nil,
 	)
 	c.workingSetPeak = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "working_set_bytes_peak"),
+		prometheus.BuildFQName(types.Namespace, Name, "working_set_bytes_peak"),
 		"Maximum number of bytes in the working set of this process at any point in time. The working set is the set of memory pages touched recently by the threads in the process. If free memory in the computer is above a threshold, pages are left in the working set of a process even if they are not in use. When free memory falls below a threshold, pages are trimmed from working sets. If they are needed, they are then soft-faulted back into the working set before they leave main memory.",
 		[]string{"session_name"},
 		nil,
@@ -220,7 +220,7 @@ func (c *Collector) Build(logger *slog.Logger, wmiClient *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collectWTSSessions(logger, ch); err != nil {
 		logger.Error("failed collecting terminal services session infos",
@@ -271,7 +271,7 @@ type perflibTerminalServicesSession struct {
 	WorkingSetPeak        float64 `perflib:"Working Set Peak"`
 }
 
-func (c *Collector) collectTSSessionCounters(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectTSSessionCounters(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	dst := make([]perflibTerminalServicesSession, 0)
 
@@ -399,7 +399,7 @@ type perflibRemoteDesktopConnectionBrokerCounterset struct {
 	FailedConnections     float64 `perflib:"Failed Connections"`
 }
 
-func (c *Collector) collectCollectionBrokerPerformanceCounter(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectCollectionBrokerPerformanceCounter(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	dst := make([]perflibRemoteDesktopConnectionBrokerCounterset, 0)
 

internal/collector/textfile/textfile.go

@@ -29,7 +29,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/dimchansky/utfbom"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	dto "github.com/prometheus/client_model/go"
 	"github.com/prometheus/common/expfmt"
@@ -110,7 +110,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 	)
 
 	c.mTimeDesc = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, "textfile", "mtime_seconds"),
+		prometheus.BuildFQName(types.Namespace, "textfile", "mtime_seconds"),
 		"Unixtime mtime of textfiles successfully read.",
 		[]string{"file"},
 		nil,
@@ -308,7 +308,7 @@ func (cr carriageReturnFilteringReader) Read(p []byte) (int, error) {
 }
 
 // Collect implements the Collector interface.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	errorMetric := 0.0
 	mTimes := map[string]time.Time{}
@@ -395,7 +395,7 @@ func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch cha
 	// Export if there were errors.
 	ch <- prometheus.MustNewConstMetric(
 		prometheus.NewDesc(
-			prometheus.BuildFQName(types2.Namespace, "textfile", "scrape_error"),
+			prometheus.BuildFQName(types.Namespace, "textfile", "scrape_error"),
 			"1 if there was an error opening or reading a file, 0 otherwise",
 			nil, nil,
 		),

internal/collector/thermalzone/thermalzone.go

@@ -7,7 +7,7 @@ import (
 	"log/slog"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -63,7 +63,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 	c.wmiClient = wmiClient
 	c.temperature = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "temperature_celsius"),
+		prometheus.BuildFQName(types.Namespace, Name, "temperature_celsius"),
 		"(Temperature)",
 		[]string{
 			"name",
@@ -71,7 +71,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 		nil,
 	)
 	c.percentPassiveLimit = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "percent_passive_limit"),
+		prometheus.BuildFQName(types.Namespace, Name, "percent_passive_limit"),
 		"(PercentPassiveLimit)",
 		[]string{
 			"name",
@@ -79,7 +79,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 		nil,
 	)
 	c.throttleReasons = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "throttle_reasons"),
+		prometheus.BuildFQName(types.Namespace, Name, "throttle_reasons"),
 		"(ThrottleReasons)",
 		[]string{
 			"name",
@@ -92,7 +92,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ch); err != nil {
 		logger.Error("failed collecting thermalzone metrics",

internal/collector/time/time.go

@@ -10,7 +10,7 @@ import (
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/headers/kernel32"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 	"golang.org/x/sys/windows"
@@ -66,49 +66,49 @@ func (c *Collector) Close(_ *slog.Logger) error {
 
 func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	c.currentTime = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "current_timestamp_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "current_timestamp_seconds"),
 		"OperatingSystem.LocalDateTime",
 		nil,
 		nil,
 	)
 	c.timezone = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "timezone"),
+		prometheus.BuildFQName(types.Namespace, Name, "timezone"),
 		"OperatingSystem.LocalDateTime",
 		[]string{"timezone"},
 		nil,
 	)
 	c.clockFrequencyAdjustmentPPBTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "clock_frequency_adjustment_ppb_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "clock_frequency_adjustment_ppb_total"),
 		"Total adjustment made to the local system clock frequency by W32Time in Parts Per Billion (PPB) units.",
 		nil,
 		nil,
 	)
 	c.computedTimeOffset = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "computed_time_offset_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "computed_time_offset_seconds"),
 		"Absolute time offset between the system clock and the chosen time source, in seconds",
 		nil,
 		nil,
 	)
 	c.ntpClientTimeSourceCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ntp_client_time_sources"),
+		prometheus.BuildFQName(types.Namespace, Name, "ntp_client_time_sources"),
 		"Active number of NTP Time sources being used by the client",
 		nil,
 		nil,
 	)
 	c.ntpRoundTripDelay = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ntp_round_trip_delay_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "ntp_round_trip_delay_seconds"),
 		"Roundtrip delay experienced by the NTP client in receiving a response from the server for the most recent request, in seconds",
 		nil,
 		nil,
 	)
 	c.ntpServerOutgoingResponsesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ntp_server_outgoing_responses_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "ntp_server_outgoing_responses_total"),
 		"Total number of requests responded to by NTP server",
 		nil,
 		nil,
 	)
 	c.ntpServerIncomingRequestsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "ntp_server_incoming_requests_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "ntp_server_incoming_requests_total"),
 		"Total number of requests received by NTP server",
 		nil,
 		nil,
@@ -119,7 +119,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	errs := make([]error, 0, 2)
@@ -178,7 +178,7 @@ func (c *Collector) collectTime(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
-func (c *Collector) collectNTP(ctx *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) collectNTP(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 
 	var dst []windowsTime // Single-instance class, array is required but will have single entry.

internal/collector/updates/updates.go

@@ -15,7 +15,7 @@ import (
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/go-ole/go-ole"
 	"github.com/go-ole/go-ole/oleutil"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -93,21 +93,21 @@ func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
 	}
 
 	c.pendingUpdate = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "pending_info"),
+		prometheus.BuildFQName(types.Namespace, Name, "pending_info"),
 		"Pending Windows Updates",
 		[]string{"category", "severity", "title"},
 		nil,
 	)
 
 	c.queryDurationSeconds = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "scrape_query_duration_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "scrape_query_duration_seconds"),
 		"Duration of the last scrape query to the Windows Update API",
 		nil,
 		nil,
 	)
 
 	c.lastScrapeMetric = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "scrape_timestamp_seconds"),
+		prometheus.BuildFQName(types.Namespace, Name, "scrape_timestamp_seconds"),
 		"Timestamp of the last scrape",
 		nil,
 		nil,
@@ -122,7 +122,7 @@ func (c *Collector) GetPerfCounter(_ *slog.Logger) ([]string, error) {
 	return []string{}, nil
 }
 
-func (c *Collector) Collect(_ *types2.ScrapeContext, _ *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, _ *slog.Logger, ch chan<- prometheus.Metric) error {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 

internal/collector/vmware/vmware.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/perflib"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -82,116 +82,116 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 	c.wmiClient = wmiClient
 
 	c.memActive = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mem_active_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "mem_active_bytes"),
 		"(MemActiveMB)",
 		nil,
 		nil,
 	)
 	c.memBallooned = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mem_ballooned_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "mem_ballooned_bytes"),
 		"(MemBalloonedMB)",
 		nil,
 		nil,
 	)
 	c.memLimit = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mem_limit_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "mem_limit_bytes"),
 		"(MemLimitMB)",
 		nil,
 		nil,
 	)
 	c.memMapped = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mem_mapped_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "mem_mapped_bytes"),
 		"(MemMappedMB)",
 		nil,
 		nil,
 	)
 	c.memOverhead = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mem_overhead_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "mem_overhead_bytes"),
 		"(MemOverheadMB)",
 		nil,
 		nil,
 	)
 	c.memReservation = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mem_reservation_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "mem_reservation_bytes"),
 		"(MemReservationMB)",
 		nil,
 		nil,
 	)
 	c.memShared = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mem_shared_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "mem_shared_bytes"),
 		"(MemSharedMB)",
 		nil,
 		nil,
 	)
 	c.memSharedSaved = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mem_shared_saved_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "mem_shared_saved_bytes"),
 		"(MemSharedSavedMB)",
 		nil,
 		nil,
 	)
 	c.memShares = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mem_shares"),
+		prometheus.BuildFQName(types.Namespace, Name, "mem_shares"),
 		"(MemShares)",
 		nil,
 		nil,
 	)
 	c.memSwapped = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mem_swapped_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "mem_swapped_bytes"),
 		"(MemSwappedMB)",
 		nil,
 		nil,
 	)
 	c.memTargetSize = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mem_target_size_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "mem_target_size_bytes"),
 		"(MemTargetSizeMB)",
 		nil,
 		nil,
 	)
 	c.memUsed = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "mem_used_bytes"),
+		prometheus.BuildFQName(types.Namespace, Name, "mem_used_bytes"),
 		"(MemUsedMB)",
 		nil,
 		nil,
 	)
 
 	c.cpuLimitMHz = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cpu_limit_mhz"),
+		prometheus.BuildFQName(types.Namespace, Name, "cpu_limit_mhz"),
 		"(CpuLimitMHz)",
 		nil,
 		nil,
 	)
 	c.cpuReservationMHz = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cpu_reservation_mhz"),
+		prometheus.BuildFQName(types.Namespace, Name, "cpu_reservation_mhz"),
 		"(CpuReservationMHz)",
 		nil,
 		nil,
 	)
 	c.cpuShares = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cpu_shares"),
+		prometheus.BuildFQName(types.Namespace, Name, "cpu_shares"),
 		"(CpuShares)",
 		nil,
 		nil,
 	)
 	c.cpuStolenTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cpu_stolen_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cpu_stolen_seconds_total"),
 		"(CpuStolenMs)",
 		nil,
 		nil,
 	)
 	c.cpuTimeTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cpu_time_seconds_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cpu_time_seconds_total"),
 		"(CpuTimePercents)",
 		nil,
 		nil,
 	)
 	c.effectiveVMSpeedMHz = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "effective_vm_speed_mhz"),
+		prometheus.BuildFQName(types.Namespace, Name, "effective_vm_speed_mhz"),
 		"(EffectiveVMSpeedMHz)",
 		nil,
 		nil,
 	)
 	c.hostProcessorSpeedMHz = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "host_processor_speed_mhz"),
+		prometheus.BuildFQName(types.Namespace, Name, "host_processor_speed_mhz"),
 		"(HostProcessorSpeedMHz)",
 		nil,
 		nil,
@@ -202,7 +202,7 @@ func (c *Collector) Build(_ *slog.Logger, wmiClient *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collectMem(ch); err != nil {
 		logger.Error("failed collecting vmware memory metrics",

internal/collector/vmware_blast/vmware_blast.go

@@ -7,7 +7,7 @@ import (
 	"log/slog"
 
 	"github.com/alecthomas/kingpin/v2"
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/yusufpapurcu/wmi"
 )
@@ -158,426 +158,426 @@ func (c *Collector) Build(logger *slog.Logger, wmiClient *wmi.Client) error {
 	c.wmiClient = wmiClient
 
 	c.audioReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "audio_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "audio_received_bytes_total"),
 		"(AudioReceivedBytes)",
 		nil,
 		nil,
 	)
 	c.audioReceivedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "audio_received_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "audio_received_packets_total"),
 		"(AudioReceivedPackets)",
 		nil,
 		nil,
 	)
 	c.audioTransmittedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "audio_transmitted_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "audio_transmitted_bytes_total"),
 		"(AudioTransmittedBytes)",
 		nil,
 		nil,
 	)
 	c.audioTransmittedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "audio_transmitted_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "audio_transmitted_packets_total"),
 		"(AudioTransmittedPackets)",
 		nil,
 		nil,
 	)
 
 	c.cdrReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cdr_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cdr_received_bytes_total"),
 		"(CDRReceivedBytes)",
 		nil,
 		nil,
 	)
 	c.cdrReceivedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cdr_received_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cdr_received_packets_total"),
 		"(CDRReceivedPackets)",
 		nil,
 		nil,
 	)
 	c.cdrTransmittedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cdr_transmitted_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cdr_transmitted_bytes_total"),
 		"(CDRTransmittedBytes)",
 		nil,
 		nil,
 	)
 	c.cdrTransmittedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "cdr_transmitted_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "cdr_transmitted_packets_total"),
 		"(CDRTransmittedPackets)",
 		nil,
 		nil,
 	)
 
 	c.clipboardReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "clipboard_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "clipboard_received_bytes_total"),
 		"(ClipboardReceivedBytes)",
 		nil,
 		nil,
 	)
 	c.clipboardReceivedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "clipboard_received_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "clipboard_received_packets_total"),
 		"(ClipboardReceivedPackets)",
 		nil,
 		nil,
 	)
 	c.clipboardTransmittedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "clipboard_transmitted_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "clipboard_transmitted_bytes_total"),
 		"(ClipboardTransmittedBytes)",
 		nil,
 		nil,
 	)
 	c.clipboardTransmittedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "clipboard_transmitted_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "clipboard_transmitted_packets_total"),
 		"(ClipboardTransmittedPackets)",
 		nil,
 		nil,
 	)
 
 	c.html5MMRReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "html5_mmr_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "html5_mmr_received_bytes_total"),
 		"(HTML5MMRReceivedBytes)",
 		nil,
 		nil,
 	)
 	c.html5MMRReceivedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "html5_mmr_received_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "html5_mmr_received_packets_total"),
 		"(HTML5MMRReceivedPackets)",
 		nil,
 		nil,
 	)
 	c.html5MMRTransmittedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "html5_mmr_transmitted_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "html5_mmr_transmitted_bytes_total"),
 		"(HTML5MMRTransmittedBytes)",
 		nil,
 		nil,
 	)
 	c.html5MMRTransmittedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "html5_mmr_transmitted_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "html5_mmr_transmitted_packets_total"),
 		"(HTML5MMRTransmittedPackets)",
 		nil,
 		nil,
 	)
 
 	c.imagingDirtyFramesPerSecond = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_dirty_frames_per_second"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_dirty_frames_per_second"),
 		"(ImagingDirtyFramesPerSecond)",
 		nil,
 		nil,
 	)
 	c.imagingFBCRate = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_fbc_rate"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_fbc_rate"),
 		"(ImagingFBCRate)",
 		nil,
 		nil,
 	)
 	c.imagingFramesPerSecond = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_frames_per_second"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_frames_per_second"),
 		"(ImagingFramesPerSecond)",
 		nil,
 		nil,
 	)
 	c.imagingPollRate = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_poll_rate"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_poll_rate"),
 		"(ImagingPollRate)",
 		nil,
 		nil,
 	)
 	c.imagingReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_received_bytes_total"),
 		"(ImagingReceivedBytes)",
 		nil,
 		nil,
 	)
 	c.imagingReceivedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_received_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_received_packets_total"),
 		"(ImagingReceivedPackets)",
 		nil,
 		nil,
 	)
 	c.imagingTotalDirtyFrames = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_total_dirty_frames_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_total_dirty_frames_total"),
 		"(ImagingTotalDirtyFrames)",
 		nil,
 		nil,
 	)
 	c.imagingTotalFBC = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_fbc_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_fbc_total"),
 		"(ImagingTotalFBC)",
 		nil,
 		nil,
 	)
 	c.imagingTotalFrames = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_frames_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_frames_total"),
 		"(ImagingTotalFrames)",
 		nil,
 		nil,
 	)
 	c.imagingTotalPoll = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_poll_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_poll_total"),
 		"(ImagingTotalPoll)",
 		nil,
 		nil,
 	)
 	c.imagingTransmittedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_transmitted_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_transmitted_bytes_total"),
 		"(ImagingTransmittedBytes)",
 		nil,
 		nil,
 	)
 	c.imagingTransmittedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "imaging_transmitted_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "imaging_transmitted_packets_total"),
 		"(ImagingTransmittedPackets)",
 		nil,
 		nil,
 	)
 
 	c.rtAVReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "rtav_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "rtav_received_bytes_total"),
 		"(RTAVReceivedBytes)",
 		nil,
 		nil,
 	)
 	c.rtAVReceivedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "rtav_received_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "rtav_received_packets_total"),
 		"(RTAVReceivedPackets)",
 		nil,
 		nil,
 	)
 	c.rtAVTransmittedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "rtav_transmitted_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "rtav_transmitted_bytes_total"),
 		"(RTAVTransmittedBytes)",
 		nil,
 		nil,
 	)
 	c.rtAVTransmittedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "rtav_transmitted_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "rtav_transmitted_packets_total"),
 		"(RTAVTransmittedPackets)",
 		nil,
 		nil,
 	)
 
 	c.serialPortAndScannerReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "serial_port_and_scanner_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "serial_port_and_scanner_received_bytes_total"),
 		"(SerialPortandScannerReceivedBytes)",
 		nil,
 		nil,
 	)
 	c.serialPortAndScannerReceivedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "serial_port_and_scanner_received_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "serial_port_and_scanner_received_packets_total"),
 		"(SerialPortandScannerReceivedPackets)",
 		nil,
 		nil,
 	)
 	c.serialPortAndScannerTransmittedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "serial_port_and_scanner_transmitted_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "serial_port_and_scanner_transmitted_bytes_total"),
 		"(SerialPortandScannerTransmittedBytes)",
 		nil,
 		nil,
 	)
 	c.serialPortAndScannerTransmittedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "serial_port_and_scanner_transmitted_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "serial_port_and_scanner_transmitted_packets_total"),
 		"(SerialPortandScannerTransmittedPackets)",
 		nil,
 		nil,
 	)
 
 	c.sessionAutomaticReconnectCount = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_automatic_reconnect_count_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_automatic_reconnect_count_total"),
 		"(SessionAutomaticReconnectCount)",
 		nil,
 		nil,
 	)
 	c.sessionCumulativeReceivedBytesOverTCP = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_cumlative_received_bytes_over_tcp_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_cumlative_received_bytes_over_tcp_total"),
 		"(SessionCumulativeReceivedBytesOverTCP)",
 		nil,
 		nil,
 	)
 	c.sessionCumulativeReceivedBytesOverUDP = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_cumlative_received_bytes_over_udp_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_cumlative_received_bytes_over_udp_total"),
 		"(SessionCumulativeReceivedBytesOverUDP)",
 		nil,
 		nil,
 	)
 	c.sessionCumulativeTransmittedBytesOverTCP = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_cumlative_transmitted_bytes_over_tcp_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_cumlative_transmitted_bytes_over_tcp_total"),
 		"(SessionCumulativeTransmittedBytesOverTCP)",
 		nil,
 		nil,
 	)
 	c.sessionCumulativeTransmittedBytesOverUDP = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_cumlative_transmitted_bytes_over_udp_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_cumlative_transmitted_bytes_over_udp_total"),
 		"(SessionCumulativeTransmittedBytesOverUDP)",
 		nil,
 		nil,
 	)
 	c.sessionEstimatedBandwidthUplink = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_estimated_bandwidth_uplink"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_estimated_bandwidth_uplink"),
 		"(SessionEstimatedBandwidthUplink)",
 		nil,
 		nil,
 	)
 	c.sessionInstantaneousReceivedBytesOverTCP = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_instantaneous_received_bytes_over_tcp_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_instantaneous_received_bytes_over_tcp_total"),
 		"(SessionInstantaneousReceivedBytesOverTCP)",
 		nil,
 		nil,
 	)
 	c.sessionInstantaneousReceivedBytesOverUDP = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_instantaneous_received_bytes_over_udp_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_instantaneous_received_bytes_over_udp_total"),
 		"(SessionInstantaneousReceivedBytesOverUDP)",
 		nil,
 		nil,
 	)
 	c.sessionInstantaneousTransmittedBytesOverTCP = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_instantaneous_transmitted_bytes_over_tcp_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_instantaneous_transmitted_bytes_over_tcp_total"),
 		"(SessionInstantaneousTransmittedBytesOverTCP)",
 		nil,
 		nil,
 	)
 	c.sessionInstantaneousTransmittedBytesOverUDP = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_instantaneous_transmitted_bytes_over_udp_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_instantaneous_transmitted_bytes_over_udp_total"),
 		"(SessionInstantaneousTransmittedBytesOverUDP)",
 		nil,
 		nil,
 	)
 	c.sessionJitterUplink = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_jitter_uplink"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_jitter_uplink"),
 		"(SessionJitterUplink)",
 		nil,
 		nil,
 	)
 	c.sessionPacketLossUplink = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_packet_loss_uplink"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_packet_loss_uplink"),
 		"(SessionPacketLossUplink)",
 		nil,
 		nil,
 	)
 	c.sessionReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_received_bytes_total"),
 		"(SessionReceivedBytes)",
 		nil,
 		nil,
 	)
 	c.sessionReceivedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_received_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_received_packets_total"),
 		"(SessionReceivedPackets)",
 		nil,
 		nil,
 	)
 	c.sessionRTT = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_rtt"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_rtt"),
 		"(SessionRTT)",
 		nil,
 		nil,
 	)
 	c.sessionTransmittedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_transmitted_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_transmitted_bytes_total"),
 		"(SessionTransmittedBytes)",
 		nil,
 		nil,
 	)
 	c.sessionTransmittedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "session_transmitted_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "session_transmitted_packets_total"),
 		"(SessionTransmittedPackets)",
 		nil,
 		nil,
 	)
 
 	c.skypeForBusinessControlReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "skype_for_business_control_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "skype_for_business_control_received_bytes_total"),
 		"(SkypeforBusinessControlReceivedBytes)",
 		nil,
 		nil,
 	)
 	c.skypeForBusinessControlReceivedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "skype_for_business_control_received_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "skype_for_business_control_received_packets_total"),
 		"(SkypeforBusinessControlReceivedPackets)",
 		nil,
 		nil,
 	)
 	c.skypeForBusinessControlTransmittedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "skype_for_business_control_transmitted_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "skype_for_business_control_transmitted_bytes_total"),
 		"(SkypeforBusinessControlTransmittedBytes)",
 		nil,
 		nil,
 	)
 	c.skypeForBusinessControlTransmittedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "skype_for_business_control_transmitted_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "skype_for_business_control_transmitted_packets_total"),
 		"(SkypeforBusinessControlTransmittedPackets)",
 		nil,
 		nil,
 	)
 
 	c.thinPrintReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "thinprint_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "thinprint_received_bytes_total"),
 		"(ThinPrintReceivedBytes)",
 		nil,
 		nil,
 	)
 	c.thinPrintReceivedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "thinprint_received_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "thinprint_received_packets_total"),
 		"(ThinPrintReceivedPackets)",
 		nil,
 		nil,
 	)
 	c.thinPrintTransmittedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "thinprint_transmitted_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "thinprint_transmitted_bytes_total"),
 		"(ThinPrintTransmittedBytes)",
 		nil,
 		nil,
 	)
 	c.thinPrintTransmittedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "thinprint_transmitted_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "thinprint_transmitted_packets_total"),
 		"(ThinPrintTransmittedPackets)",
 		nil,
 		nil,
 	)
 
 	c.usbReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "usb_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "usb_received_bytes_total"),
 		"(USBReceivedBytes)",
 		nil,
 		nil,
 	)
 	c.usbReceivedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "usb_received_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "usb_received_packets_total"),
 		"(USBReceivedPackets)",
 		nil,
 		nil,
 	)
 	c.usbTransmittedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "usb_transmitted_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "usb_transmitted_bytes_total"),
 		"(USBTransmittedBytes)",
 		nil,
 		nil,
 	)
 	c.usbTransmittedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "usb_transmitted_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "usb_transmitted_packets_total"),
 		"(USBTransmittedPackets)",
 		nil,
 		nil,
 	)
 
 	c.windowsMediaMMRReceivedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "windows_media_mmr_received_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "windows_media_mmr_received_bytes_total"),
 		"(WindowsMediaMMRReceivedBytes)",
 		nil,
 		nil,
 	)
 	c.windowsMediaMMRReceivedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "windows_media_mmr_received_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "windows_media_mmr_received_packets_total"),
 		"(WindowsMediaMMRReceivedPackets)",
 		nil,
 		nil,
 	)
 	c.windowsMediaMMRTransmittedBytes = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "windows_media_mmr_transmitted_bytes_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "windows_media_mmr_transmitted_bytes_total"),
 		"(WindowsMediaMMRTransmittedBytes)",
 		nil,
 		nil,
 	)
 	c.windowsMediaMMRTransmittedPackets = prometheus.NewDesc(
-		prometheus.BuildFQName(types2.Namespace, Name, "windows_media_mmr_transmitted_packets_total"),
+		prometheus.BuildFQName(types.Namespace, Name, "windows_media_mmr_transmitted_packets_total"),
 		"(WindowsMediaMMRTransmittedPackets)",
 		nil,
 		nil,
@@ -588,7 +588,7 @@ func (c *Collector) Build(logger *slog.Logger, wmiClient *wmi.Client) error {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(_ *types2.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
 	logger = logger.With(slog.String("collector", Name))
 	if err := c.collectAudio(ch); err != nil {
 		logger.Error("failed collecting vmware blast audio metrics",

pkg/collector/prometheus.go

@@ -11,7 +11,7 @@ import (
 	"sync/atomic"
 	"time"
 
-	types2 "github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
@@ -53,31 +53,31 @@ func (c *MetricCollectors) NewPrometheusCollector(timeout time.Duration, logger
 		metricCollectors:  c,
 		logger:            logger,
 		scrapeDurationDesc: prometheus.NewDesc(
-			prometheus.BuildFQName(types2.Namespace, "exporter", "scrape_duration_seconds"),
+			prometheus.BuildFQName(types.Namespace, "exporter", "scrape_duration_seconds"),
 			"windows_exporter: Total scrape duration.",
 			nil,
 			nil,
 		),
 		collectorScrapeDurationDesc: prometheus.NewDesc(
-			prometheus.BuildFQName(types2.Namespace, "exporter", "collector_duration_seconds"),
+			prometheus.BuildFQName(types.Namespace, "exporter", "collector_duration_seconds"),
 			"windows_exporter: Duration of a collection.",
 			[]string{"collector"},
 			nil,
 		),
 		collectorScrapeSuccessDesc: prometheus.NewDesc(
-			prometheus.BuildFQName(types2.Namespace, "exporter", "collector_success"),
+			prometheus.BuildFQName(types.Namespace, "exporter", "collector_success"),
 			"windows_exporter: Whether the collector was successful.",
 			[]string{"collector"},
 			nil,
 		),
 		collectorScrapeTimeoutDesc: prometheus.NewDesc(
-			prometheus.BuildFQName(types2.Namespace, "exporter", "collector_timeout"),
+			prometheus.BuildFQName(types.Namespace, "exporter", "collector_timeout"),
 			"windows_exporter: Whether the collector timed out.",
 			[]string{"collector"},
 			nil,
 		),
 		snapshotDuration: prometheus.NewDesc(
-			prometheus.BuildFQName(types2.Namespace, "exporter", "perflib_snapshot_duration_seconds"),
+			prometheus.BuildFQName(types.Namespace, "exporter", "perflib_snapshot_duration_seconds"),
 			"Duration of perflib snapshot capture",
 			nil,
 			nil,
@@ -166,7 +166,7 @@ func (p *Prometheus) Collect(ch chan<- prometheus.Metric) {
 	)
 }
 
-func (p *Prometheus) execute(name string, c Collector, scrapeCtx *types2.ScrapeContext, ch chan<- prometheus.Metric) collectorStatusCode {
+func (p *Prometheus) execute(name string, c Collector, scrapeCtx *types.ScrapeContext, ch chan<- prometheus.Metric) collectorStatusCode {
 	var (
 		err        error
 		numMetrics int