import type { CreateServicePolicyOptions, ServicePolicy } from "@metamask/controller-utils";
import type { Messenger } from "@metamask/messenger";
import type { IDisposable } from "cockatiel";
import type { AnalyticsDataRegulationServiceMethodActions } from "./AnalyticsDataRegulationService-method-action-types.cjs";
import { DATA_DELETE_RESPONSE_STATUSES } from "./types.cjs";
import type { DataDeleteStatus } from "./types.cjs";
/**
 * The name of the {@link AnalyticsDataRegulationService}, used to namespace the
 * service's actions and events.
 */
export declare const serviceName = "AnalyticsDataRegulationService";
/**
 * Actions that {@link AnalyticsDataRegulationService} exposes to other consumers.
 */
export type AnalyticsDataRegulationServiceActions = AnalyticsDataRegulationServiceMethodActions;
/**
 * Actions from other messengers that {@link AnalyticsDataRegulationServiceMessenger} calls.
 */
type AllowedActions = never;
/**
 * Events that {@link AnalyticsDataRegulationService} exposes to other consumers.
 */
export type AnalyticsDataRegulationServiceEvents = never;
/**
 * Events from other messengers that {@link AnalyticsDataRegulationService} subscribes to.
 */
type AllowedEvents = never;
/**
 * The messenger which is restricted to actions and events accessed by
 * {@link AnalyticsDataRegulationService}.
 */
export type AnalyticsDataRegulationServiceMessenger = Messenger<typeof serviceName, AnalyticsDataRegulationServiceActions | AllowedActions, AnalyticsDataRegulationServiceEvents | AllowedEvents>;
/**
 * Options for constructing {@link AnalyticsDataRegulationService}.
 */
export type AnalyticsDataRegulationServiceOptions = {
    /**
     * The messenger suited for this service.
     */
    messenger: AnalyticsDataRegulationServiceMessenger;
    /**
     * A function that can be used to make an HTTP request.
     */
    fetch: typeof fetch;
    /**
     * Segment API source ID (required for creating regulations).
     */
    segmentSourceId: string;
    /**
     * Base URL for the proxy endpoint that communicates with Segment's Regulations API.
     * This is a proxy endpoint (not Segment API directly) that forwards requests to Segment's
     * Regulations API and adds authentication tokens. The endpoint URL varies by environment
     * (e.g., development, staging, production) and should be configured accordingly.
     * Example: 'https://proxy.example.com/v1beta'
     */
    segmentRegulationsEndpoint: string;
    /**
     * Options to pass to `createServicePolicy`, which is used to wrap each request.
     */
    policyOptions?: CreateServicePolicyOptions;
};
/**
 * This service object is responsible for making requests to the Segment Regulations API
 * via a proxy endpoint for GDPR/CCPA data deletion functionality.
 *
 * @example
 *
 * ```ts
 * import { Messenger } from '@metamask/messenger';
 * import type {
 *   AnalyticsDataRegulationServiceActions,
 *   AnalyticsDataRegulationServiceEvents,
 * } from '@metamask/analytics-data-regulation-controller';
 *
 * const rootMessenger = new Messenger<
 *   'Root',
 *   AnalyticsDataRegulationServiceActions,
 *   AnalyticsDataRegulationServiceEvents
 * >({ namespace: 'Root' });
 * const serviceMessenger = new Messenger<
 *   'AnalyticsDataRegulationService',
 *   AnalyticsDataRegulationServiceActions,
 *   AnalyticsDataRegulationServiceEvents,
 *   typeof rootMessenger,
 * >({
 *   namespace: 'AnalyticsDataRegulationService',
 *   parent: rootMessenger,
 * });
 * // Instantiate the service to register its actions on the messenger
 * new AnalyticsDataRegulationService({
 *   messenger: serviceMessenger,
 *   fetch,
 *   segmentSourceId: 'abc123',
 *   segmentRegulationsEndpoint: 'https://proxy.example.com/v1beta',
 * });
 *
 * // Later...
 * // Create a data deletion task
 * const response = await rootMessenger.call(
 *   'AnalyticsDataRegulationService:createDataDeletionTask',
 *   'user-analytics-id',
 * );
 * ```
 */
export declare class AnalyticsDataRegulationService {
    #private;
    /**
     * The name of the service.
     */
    readonly name: typeof serviceName;
    /**
     * Constructs a new AnalyticsDataRegulationService object.
     *
     * @param options - The constructor options.
     */
    constructor(options: AnalyticsDataRegulationServiceOptions);
    /**
     * Registers a handler that will be called after a request returns a non-500
     * response, causing a retry. Primarily useful in tests where timers are being
     * mocked.
     *
     * @param listener - The handler to be called.
     * @returns An object that can be used to unregister the handler.
     * @see {@link createServicePolicy}
     */
    onRetry(listener: Parameters<ServicePolicy['onRetry']>[0]): IDisposable;
    /**
     * Registers a handler that will be called after a set number of retry rounds
     * prove that requests to the API endpoint consistently return a 5xx response.
     *
     * @param listener - The handler to be called.
     * @returns An object that can be used to unregister the handler.
     * @see {@link createServicePolicy}
     */
    onBreak(listener: Parameters<ServicePolicy['onBreak']>[0]): IDisposable;
    /**
     * Registers a handler that will be called under one of two circumstances:
     *
     * 1. After a set number of retries prove that requests to the API
     * consistently result in failures.
     * 2. After a successful request is made to the API, but the response takes
     * longer than a set duration to return.
     *
     * @param listener - The handler to be called.
     * @returns An object that can be used to unregister the handler.
     */
    onDegraded(listener: Parameters<ServicePolicy['onDegraded']>[0]): IDisposable;
    /**
     * Creates a DELETE_ONLY regulation for the given analyticsId.
     *
     * @param analyticsId - The analytics ID of the user for whom to create the deletion task.
     * @returns Promise resolving to a successful deletion regulation response.
     * @throws Error if the request fails or the response is invalid.
     */
    createDataDeletionTask(analyticsId: string): Promise<{
        status: typeof DATA_DELETE_RESPONSE_STATUSES.Success;
        regulateId: string;
    }>;
    /**
     * Checks the status of a regulation by ID.
     *
     * @param regulationId - The regulation ID to check.
     * @returns Promise resolving to a successful regulation status response.
     * @throws Error if the request fails or the response is invalid.
     */
    checkDataDeleteStatus(regulationId: string): Promise<{
        status: typeof DATA_DELETE_RESPONSE_STATUSES.Success;
        dataDeleteStatus: DataDeleteStatus;
    }>;
}
export {};
//# sourceMappingURL=AnalyticsDataRegulationService.d.cts.map