@transcend-io/airgap.js-types 14.1.1 → 14.2.0

package/dist/core.d.mts

@@ -0,0 +1,976 @@
+import * as _transcend_io_type_utils0 from "@transcend-io/type-utils";
+import * as t from "io-ts";
+
+//#region src/core.d.ts
+/** Transcend logger items */
+type LogItem = {
+  /** Log item content */content: any; /** Log item styles */
+  styles: string[];
+};
+/** Transcend logger entry tag */
+type LogTag = LogItem & {
+  /** Log tag content must be a string */content: string; /** Log tags must have only one style */
+  styles: string[1];
+};
+/** Transcend logger entry message */
+type LogMessage = LogItem;
+/** Console-safe log levels */
+declare const ConsoleSafeLogLevel: t.KeyofC<{
+  info: null;
+  log: null;
+  warn: null;
+  debug: null;
+  error: null;
+  trace: null;
+  group: null;
+  groupCollapsed: null;
+  groupEnd: null;
+}>;
+/** Override type */
+type ConsoleSafeLogLevel = t.TypeOf<typeof ConsoleSafeLogLevel>;
+/** Airgap log levels */
+declare const LogLevel: t.UnionC<[t.KeyofC<{
+  info: null;
+  log: null;
+  warn: null;
+  debug: null;
+  error: null;
+  trace: null;
+  group: null;
+  groupCollapsed: null;
+  groupEnd: null;
+}>, t.LiteralC<"fatal">]>;
+/** Override type */
+type LogLevel = t.TypeOf<typeof LogLevel>;
+/** Airgap logger entry types */
+type LogEntryType = LogLevel;
+/** Airgap logger entries */
+type LogEntry = {
+  /** Log entry tag */tag: LogTag; /** Log entry message */
+  message: LogMessage;
+};
+/**
+ * Log emitter function
+ */
+type LogEmitter = {
+  /** Styled log emitter function */styled(styles?: null | string | string[], ...entries: any[]): void;
+} & ((...entries: any[]) => void);
+/** Transcend Logger API */
+type Logger = {
+  /**
+   * Set log tag during callback execution or from
+   * this point on if no callback is provided.
+   */
+  tag(logTag: string, callback?: () => any): void;
+} & { [method in LogLevel]: LogEmitter };
+/** AirgapAuth auth options */
+type AirgapAuthMap = {
+  /** A `load` event from a just-loaded airgap.js script element (which implies auth by being loaded before airgap.js) */load?: Event; /** A user-initiated interaction event that was just dispatched. */
+  interaction?: Event; /** Automatically reload the page if needed to remove CSP. `false` by default. */
+  autoReload?: boolean;
+  /**
+   * Additional authorization key automatically conferred by airgap.js via setAuth() API for UI modules.
+   * Required when optional strict authorization mode is enabled.
+   */
+  key?: symbol;
+};
+/** Airgap authorization proof */
+type AirgapAuth = null | AirgapAuthMap
+/**
+ * A user-initiated interaction event that was just dispatched, or
+ * a `load` event from a just-loaded airgap.js script element (which implies auth by being loaded before airgap.js).
+ */
+| Event;
+/** A boolean value represented as either `'on'` or `'off'` */
+declare const BooleanString: t.KeyofC<{
+  on: null;
+  off: null;
+}>;
+/** Type override */
+type BooleanString = t.TypeOf<typeof BooleanString>;
+/** Data privacy legal regimes */
+type PrivacyRegime = string;
+interface GetPurposeTypesOptions {
+  /** Regimes to include */
+  regimes?: PrivacyRegime[];
+  /** Privacy signals to include */
+  signals?: UserPrivacySignal[];
+}
+/**
+ * Regime to purpose scope map
+ */
+type RegimeToPurposeScopes = [PrivacyRegime[], TrackingPurpose[]][];
+/** Reserved metadata, currently used for airgap module data syncing */
+interface ReservedMetadata {
+  /** Top-level key to avoid polluting the metadata key space */
+  tcmp?: Record<string, unknown>;
+}
+/**
+ * Extra metadata to be synced along with consent
+ */
+type Metadata = Record<string, unknown>;
+/** setConsent() options */
+interface ConsentOptions {
+  /** Was consent confirmed by the user? */
+  confirmed?: boolean;
+  /**
+   * Was the UI shown to the user?
+   * @deprecated It was discovered that this value was not being set reliably in some versions, and was not being used.
+   */
+  prompted?: boolean;
+  /**
+   * Extra metadata to be synced along with consent
+   *
+   * Special values:
+   * - `null` - Do not change metadata
+   * - `false` - Clear metadata
+   */
+  metadata?: (Metadata & ReservedMetadata) | null | false;
+  /** Last updated for metadata */
+  metadataTimestamp?: string;
+  /** Whether or not to return a Promise so that the caller can wait for sync to complete. By default, we do not wait for sync */
+  waitForSync?: boolean;
+  /** Last updated */
+  timestamp?: string;
+}
+/** airgap.toggle() options */
+type AirgapToggleOptions = /** Protection state */boolean | {
+  /** Protection state */protection?: boolean;
+};
+/** airgap.status format */
+interface AirgapSystemStatus {
+  /** Protection system active state */
+  protection: boolean;
+  /** Have any CSPs been activated? */
+  csp: boolean;
+  /** Monitoring system active state */
+  monitoring: boolean;
+  /** Telemetry system active state */
+  telemetry: boolean;
+}
+/**
+ * Request override config
+ */
+interface RequestOverride {
+  /** Optional tracking purposes to gate the override with lack of consent */
+  unconsented?: TrackingPurpose[];
+  /**
+   * Optional request matcher. This is a RegExp object (or string input
+   * for the RegExp constructor). Overrides apply to all requests
+   * when this is undefined.
+   */
+  matcher?: RegExp | string;
+  /** Override executor function or replacement string */
+  override: string | ((request: IPendingEvent, matcher?: RegExp) => void);
+  /** Name */
+  name?: string;
+  /** Note */
+  note?: string;
+  /** Description */
+  description?: string;
+}
+/** Airgap watcher */
+type AirgapWatcher = (request: IPendingEvent) => void;
+/**
+ * Cookie override handler. This function can modify attempted cookie mutations.
+ */
+type CookieOverride = (event: IPendingCookieMutation) => void;
+/**
+ * Passive cookie watcher. This function can view attempted cookie mutations in a read-only state.
+ */
+type CookieWatcher = (event: IPendingCookieMutation) => void;
+/** Event types (for purpose resolution) */
+type TrackingEventType = 'request' | 'cookie';
+/** Airgap sync types */
+type AirgapSyncType = 'consent' | 'quarantine';
+/** airgap.sync() options */
+interface SyncOptions {
+  /** types of data to sync */
+  sync?: AirgapSyncType[];
+  /** reset synchronized data (default: false) */
+  reset?: boolean;
+  /** sync locally (i.e. XDI) */
+  local?: boolean;
+  /** sync with remote endpoint */
+  backend?: boolean;
+  /** signed authentication token to link consent with encrypted identifier */
+  auth?: string;
+}
+/** airgap.js API */
+type AirgapAPI = Readonly<{
+  /** Embedded request watchers */watchers?: AirgapWatcher[]; /** Embedded request overrides (must specify pre-init) */
+  overrides?: RequestOverride[]; /** Embedded request overrides (must specify pre-init) */
+  cookieOverrides?: CookieOverride[]; /** Airgap ready event subscriber */
+  ready(callback: (airgap: AirgapAPI) => void): void; /** Queue of callbacks to dispatch once airgap is ready */
+  readyQueue?: ((airgap: AirgapAPI) => void)[]; /** Enqueue cross-domain data sync across all airgap bundle domains */
+  sync(options?: SyncOptions): Promise<void>;
+  /**
+   * Resolve URL input reserialization post-regulation.
+   * @param resolveOverrides - Resolve overrides. Defaults to true.
+   */
+  resolve(url: Stringifiable, resolveOverrides?: boolean): Stringifiable;
+  /**
+   * Resolve consent status for given tracking purposes. Essential purposes override opted out unessential purposes.
+   *
+   * If `use` is not provided, consent is resolved for both request and cookie tracking event types.
+   * @param trackingPurposes - Tracking purposes to resolve
+   * @param use - Optional event type to use for tracking purpose resolution
+   * @returns `true` if the applicable tracking purposes are consented.
+   */
+  isConsented(trackingPurposes: TrackingPurposes, use?: TrackingEventType): boolean; /** Get tracking consent */
+  getConsent(): TrackingConsentDetails; /** Set tracking consent */
+  setConsent(/** Airgap auth proof */
+
+  auth: AirgapAuth, /** The tracking consent options. */
+
+  consent: TrackingConsent, /** Consent options */
+
+  options?: ConsentOptions): Promise<boolean> | boolean;
+  /**
+   * Sets whether or not the Consent UI has been shown to the user
+   * @deprecated It was discovered that this function was not working reliably in some versions, and that the value it set was not being used.
+   */
+  setPrompted(state: boolean): Promise<void>; /** Consents the user to all tracking purposes (requires recent UI interaction) */
+  optIn(/** Airgap auth proof */
+
+  auth: AirgapAuth): boolean; /** Revokes consent for all tracking purposes (requires recent UI interaction) */
+  optOut(/** Airgap auth proof */
+
+  auth: AirgapAuth): boolean; /** Returns true if the user is fully-opted in to all first-order tracking purposes */
+  isOptedIn(): boolean; /** Returns true if the user is fully-opted out to all first-order tracking purposes */
+  isOptedOut(): boolean; /** Resolve regime tracking purposes. If no regimes are provided, then the user's detected regimes are used */
+  getRegimePurposes(regimes?: Set<PrivacyRegime>): Set<TrackingPurpose>; /** Get initialized tracking purposes config */
+  getPurposeTypes(): TrackingPurposesTypes; /** Override pending requests */
+  override(auth: AirgapAuth, ...overrides: RequestOverride[]): Removable; /** Override cookies */
+  overrideCookies(auth: AirgapAuth, handler: (event: IPendingCookieMutation) => void): Removable; /** Listen to pending requests passively */
+  watch(watcher: AirgapWatcher): Removable; /** Listen to cookies passively */
+  watchCookies(watcher: CookieWatcher): Removable; /** Clear airgap queue & caches. Returns `true` on success. */
+  clear(auth: AirgapAuth): boolean; /** Reset airgap queue and consent. Returns `true` on success. */
+  reset(/** An airgap auth proof */
+
+  auth: AirgapAuth, /** Automatically reload the page if needed to remove CSP. */
+
+  autoReload?: boolean): boolean; /** Check whether a URL is allowed to be loaded */
+  isAllowed(/** URL to evaluate */
+
+  url: Stringifiable, /** Should overrides be resolved? true by default */
+
+  resolveOverrides?: boolean): Promise<boolean>; /** Check whether a cookie is allowed to be set */
+  isCookieAllowed(/** IPendingCookieMutation-like object to evaluate */
+
+  cookie: string | IPendingCookieMutation | PendingCookieMutationInit, /** Should overrides be resolved? true by default */
+
+  resolveOverrides?: boolean): Promise<boolean>; /** Check whether a IPendingRequest is allowed to be loaded */
+  isRequestAllowed(/** IPendingEvent to inspect */
+
+  request: IPendingEvent, /** Should overrides be resolved? true by default */
+
+  resolveOverrides?: boolean): Promise<boolean>; /** Get purposes of URL */
+  getPurposes(/** URL to evaluate */
+
+  url: Stringifiable, /** Should overrides be resolved? true by default */
+
+  resolveOverrides?: boolean): Promise<TrackingPurposes>; /** Get purposes of IPendingRequest */
+  getRequestPurposes(/** IPendingEvent-like object to inspect */
+
+  request: string | IPendingEvent | PendingRequestInit, /** Should overrides be resolved? true by default */
+
+  resolveOverrides?: boolean): Promise<TrackingPurposes>; /** Get purposes of a cookie */
+  getCookiePurposes(/** IPendingCookieMutation-like object to evaluate */
+
+  cookie: string | IPendingCookieMutation | PendingCookieMutationInit, /** Should overrides be resolved? true by default */
+
+  resolveOverrides?: boolean): Promise<TrackingPurposes>; /** Export queues */
+  export(options?: AirgapExportOptions): AirgapQueues; /** Get a list of legal regimes that are potentially applicable to the user */
+  getRegimes(): Set<PrivacyRegime>; /** Get a list of detected active user agent privacy signals */
+  getPrivacySignals(): Set<UserPrivacySignal>; /** Toggle all airgap.js protections. Auth must be a pre-airgap.js or airgap.js script 'load' event. Returns success status */
+  toggle(auth: AirgapAuth, options?: AirgapToggleOptions): boolean; /** Current airgap.js system flags */
+  status: AirgapSystemStatus; /** airgap.js version number */
+  version: string; /** override the event listener signature for consent change events */
+  addEventListener: (type: AirgapConsentEventType, callback: ((evt: ConsentChangeEventPayload) => void) | null, options?: boolean | AddEventListenerOptions | undefined) => void;
+}> & EventTarget;
+/** airgap.export() options */
+interface AirgapExportOptions {
+  /** Send output to web endpoint */
+  endpoint?: string;
+  /** JSON pretty-print indentation (default: 0) */
+  space?: number;
+  /** Save output to disk (default: off) */
+  save?: boolean;
+  /** Filename for saving to disk */
+  filename?: string;
+}
+/** Exported airgap queues & consent */
+type AirgapQueues = Readonly<{
+  /** airgap.js version number */version: string; /** Current user consent details */
+  consent: TrackingConsentDetails; /** Navigation page URL */
+  url: Stringifiable; /** Pending requests */
+  requests: PendingRequestDescriptor[]; /** Pending mutations (same-session-only replay) */
+  mutations: PendingMutationDescriptor[]; /** Pending cookies */
+  cookies: PendingCookieMutationDescriptor[]; /** Pending cookies (same-session-only replay) */
+  cookieMutations: PendingCookieMutationDescriptor[]; /** Sent requests */
+  sentRequests?: PendingRequestDescriptor[]; /** Set cookies */
+  setCookies?: PendingCookieMutationDescriptor[];
+}>;
+/**
+ * Airgap event types that send the ConsentChangeEventDetails object with them
+ */
+type AirgapConsentEventType = 'consent-change' | 'sync' | 'consent-resolution';
+/**
+ * airgap.js event type
+ */
+type AirgapEventType = AirgapConsentEventType | 'purpose-map-load';
+interface ConsentChangeEventPayload {
+  /** consent change event details */
+  detail: ConsentChangeEventDetails;
+}
+/** 'consent-change' custom event details */
+type ConsentChangeEventDetails = {
+  /** The old tracking consent */oldConsent: TrackingConsentDetails | null; /** The new tracking consent */
+  consent: TrackingConsentDetails | null; /** The tracking consent diff (what's changed in the new consent) */
+  changes: Record<string, boolean> | null; /** Applicable privacy signals contributing to this consent change event */
+  signals?: Set<UserPrivacySignal> | null;
+};
+/** Removable process (can remove watchers, overrides, and protections) */
+type Removable = {
+  /** Remove/revoke process */remove(): void;
+};
+/** Any value which implements `toString()` */
+type Stringifiable = string | (string & {
+  toString(): string;
+});
+/** Special `defaultConsent` automatic opt-out value for any potential reason */
+declare const AutoOptOut: t.LiteralC<"Auto">;
+/** Type override */
+type AutoOptOut = t.TypeOf<typeof AutoOptOut>;
+/** Special `defaultConsent` automatic opt-out value for GDPR-protected users */
+declare const AutoOptOutForGDPR: t.LiteralC<"AutoGDPR">;
+/** Type override */
+type AutoOptOutForGDPR = t.TypeOf<typeof AutoOptOutForGDPR>;
+/**
+ * Special `defaultConsent` automatic opt-out value for users with DNT enabled.
+ * Note that DNT is enabled by default for some browsers.
+ */
+declare const AutoOptOutForDNT: t.LiteralC<"AutoDNT">;
+/** Type override */
+type AutoOptOutForDNT = t.TypeOf<typeof AutoOptOutForDNT>;
+/**
+ * Special `defaultConsent` automatic opt-out value for users with GPC enabled.
+ */
+declare const AutoOptOutForGPC: t.LiteralC<"AutoGPC">;
+/** Type override */
+type AutoOptOutForGPC = t.TypeOf<typeof AutoOptOutForGPC>;
+/** Potential values for `defaultConsent` config token list */
+declare const DefaultConsentConfigValue: t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+  on: null;
+  off: null;
+}>]>;
+/** Type override */
+type DefaultConsentConfigValue = t.TypeOf<typeof DefaultConsentConfigValue>;
+/** User-configurable user agent privacy signal */
+declare const UserPrivacySignal: t.UnionC<[t.LiteralC<"GPC">, t.LiteralC<"DNT">]>;
+/** type overload */
+type UserPrivacySignal = t.TypeOf<typeof UserPrivacySignal>;
+/** Tracking purpose metadata */
+declare const TrackingPurposeDetails: t.IntersectionC<[t.TypeC<{
+  /** Tracking purpose name */name: t.StringC; /** Tracking purpose description (used in Consent Manager UI) */
+  description: t.StringC; /** Tracking purpose default consent (default: false) */
+  defaultConsent: t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+    on: null;
+    off: null;
+  }>]>;
+  /**
+   * Is this a first-order tracking purpose? If false, this is a
+   * second-order tracking purpose that should only be used for
+   * request overrides.
+   *
+   * This parameter previously meant:
+   *   Show tracking purpose in consent manager UI.
+   *
+   * Default value: true
+   */
+  showInConsentManager: t.BooleanC; /** Allow user to configure their consent for this purpose (default: true) */
+  configurable: t.BooleanC; /** Is tracking purpose "essential" - i.e. consent is mandatory / equivalent to 'essential' permission (default: false) */
+  essential: t.BooleanC;
+}>, t.PartialC<{
+  /** Tracking type */trackingType: t.StringC; /** Respected opt-out privacy signals */
+  optOutSignals: t.ArrayC<t.UnionC<[t.LiteralC<"GPC">, t.LiteralC<"DNT">]>>;
+}>]>;
+/** Type override */
+type TrackingPurposeDetails = t.TypeOf<typeof TrackingPurposeDetails>;
+/** Tracking purposes types configuration */
+declare const TrackingPurposesTypes: t.RecordC<t.StringC, t.IntersectionC<[t.TypeC<{
+  /** Tracking purpose name */name: t.StringC; /** Tracking purpose description (used in Consent Manager UI) */
+  description: t.StringC; /** Tracking purpose default consent (default: false) */
+  defaultConsent: t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+    on: null;
+    off: null;
+  }>]>;
+  /**
+   * Is this a first-order tracking purpose? If false, this is a
+   * second-order tracking purpose that should only be used for
+   * request overrides.
+   *
+   * This parameter previously meant:
+   *   Show tracking purpose in consent manager UI.
+   *
+   * Default value: true
+   */
+  showInConsentManager: t.BooleanC; /** Allow user to configure their consent for this purpose (default: true) */
+  configurable: t.BooleanC; /** Is tracking purpose "essential" - i.e. consent is mandatory / equivalent to 'essential' permission (default: false) */
+  essential: t.BooleanC;
+}>, t.PartialC<{
+  /** Tracking type */trackingType: t.StringC; /** Respected opt-out privacy signals */
+  optOutSignals: t.ArrayC<t.UnionC<[t.LiteralC<"GPC">, t.LiteralC<"DNT">]>>;
+}>]>>;
+/** Type override */
+type TrackingPurposesTypes = t.TypeOf<typeof TrackingPurposesTypes>;
+/** Fully-resolved `defaultConsent` config */
+declare const DefaultConsentConfig: t.RecordC<t.StringC, t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+  on: null;
+  off: null;
+}>]>>;
+/** Type override */
+type DefaultConsentConfig = t.TypeOf<typeof DefaultConsentConfig>;
+/** Tracking purposes configuration */
+declare const TrackingPurposesConfig: t.IntersectionC<[t.TypeC<{
+  /** Inherit default tracking purposes config */useDefault: t.BooleanC;
+  types: t.RecordC<t.StringC, t.IntersectionC<[t.TypeC<{
+    /** Tracking purpose name */name: t.StringC; /** Tracking purpose description (used in Consent Manager UI) */
+    description: t.StringC; /** Tracking purpose default consent (default: false) */
+    defaultConsent: t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+      on: null;
+      off: null;
+    }>]>;
+    /**
+     * Is this a first-order tracking purpose? If false, this is a
+     * second-order tracking purpose that should only be used for
+     * request overrides.
+     *
+     * This parameter previously meant:
+     *   Show tracking purpose in consent manager UI.
+     *
+     * Default value: true
+     */
+    showInConsentManager: t.BooleanC; /** Allow user to configure their consent for this purpose (default: true) */
+    configurable: t.BooleanC; /** Is tracking purpose "essential" - i.e. consent is mandatory / equivalent to 'essential' permission (default: false) */
+    essential: t.BooleanC;
+  }>, t.PartialC<{
+    /** Tracking type */trackingType: t.StringC; /** Respected opt-out privacy signals */
+    optOutSignals: t.ArrayC<t.UnionC<[t.LiteralC<"GPC">, t.LiteralC<"DNT">]>>;
+  }>]>>;
+}>, t.PartialC<{
+  defaultConsent: t.UnionC<[t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+    on: null;
+    off: null;
+  }>]>, t.RecordC<t.StringC, t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+    on: null;
+    off: null;
+  }>]>>]>;
+}>]>;
+/** Type override */
+type TrackingPurposesConfig = {
+  /** Inherit default tracking purposes config (Functional, Advertising, Analytics) */useDefault: boolean; /** Tracking purpose types */
+  types: TrackingPurposesTypes; /** Default consent states (takes precedence over `TrackingPurposesTypes[purpose].defaultConsent`) */
+  defaultConsent?: DefaultConsentConfigValue | DefaultConsentConfig;
+};
+declare const TrackingConsent: t.IntersectionC<[t.PartialC<{
+  Essential: t.LiteralC<true>;
+  Unknown: t.LiteralC<false>;
+}>, t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+  on: null;
+  off: null;
+}>]>, t.UndefinedC]>>]>;
+/**
+ * Type override
+ */
+type TrackingConsent = t.TypeOf<typeof TrackingConsent>;
+declare const TrackingConsentWithNulls: t.RecordC<t.StringC, t.UnionC<[t.IntersectionC<[t.PartialC<{
+  Essential: t.LiteralC<true>;
+  Unknown: t.LiteralC<false>;
+}>, t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+  on: null;
+  off: null;
+}>]>, t.UndefinedC]>>]>, t.NullC]>>;
+/** Type override */
+type TrackingConsentWithNulls = t.TypeOf<typeof TrackingConsentWithNulls>;
+declare const CoreTrackingConsentDetails: t.IntersectionC<[t.TypeC<{
+  /**
+   * Was tracking consent confirmed by the user?
+   * If this is false, the consent was resolved from defaults & is not yet confirmed
+   */
+  confirmed: t.BooleanC; /** Consent resolution/last-modified timestamp (ISO 8601) */
+  timestamp: t.StringC;
+}>, t.PartialC<{
+  /** Has the consent been updated (including no-change confirmation) since default resolution */updated: t.BooleanC;
+  /**
+   * Whether or not the UI has been shown to the end-user (undefined in older versions of airgap.js)
+   * @deprecated It was discovered that this value was not being set reliably in some versions, and was not being used.
+   */
+  prompted: t.BooleanC; /** Arbitrary metadata that customers want to be associated with consent state */
+  metadata: t.IntersectionC<[t.PartialC<{
+    tcmp: t.PartialC<{
+      tcf: t.PartialC<{
+        tcString: t.StringC;
+      }>;
+    }>;
+  }>, t.UnknownRecordC]>; /** When the metadata was last updated */
+  metadataTimestamp: t.StringC;
+}>]>;
+/** Type override */
+type CoreTrackingConsentDetails = t.TypeOf<typeof CoreTrackingConsentDetails>;
+declare const TrackingConsentDetails: t.IntersectionC<[t.IntersectionC<[t.TypeC<{
+  /**
+   * Was tracking consent confirmed by the user?
+   * If this is false, the consent was resolved from defaults & is not yet confirmed
+   */
+  confirmed: t.BooleanC; /** Consent resolution/last-modified timestamp (ISO 8601) */
+  timestamp: t.StringC;
+}>, t.PartialC<{
+  /** Has the consent been updated (including no-change confirmation) since default resolution */updated: t.BooleanC;
+  /**
+   * Whether or not the UI has been shown to the end-user (undefined in older versions of airgap.js)
+   * @deprecated It was discovered that this value was not being set reliably in some versions, and was not being used.
+   */
+  prompted: t.BooleanC; /** Arbitrary metadata that customers want to be associated with consent state */
+  metadata: t.IntersectionC<[t.PartialC<{
+    tcmp: t.PartialC<{
+      tcf: t.PartialC<{
+        tcString: t.StringC;
+      }>;
+    }>;
+  }>, t.UnknownRecordC]>; /** When the metadata was last updated */
+  metadataTimestamp: t.StringC;
+}>]>, t.TypeC<{
+  /** Tracking consent config */purposes: t.IntersectionC<[t.PartialC<{
+    Essential: t.LiteralC<true>;
+    Unknown: t.LiteralC<false>;
+  }>, t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+    on: null;
+    off: null;
+  }>]>, t.UndefinedC]>>]>;
+}>]>;
+/** Override types. */
+type TrackingConsentDetails = t.TypeOf<typeof TrackingConsentDetails>;
+declare const TrackingConsentOptionalData: t.PartialC<{
+  /** Transparency Consent (TCF) String */tcf: t.StringC; /** US Privacy (USP) String */
+  usp: t.StringC; /** Global Privacy Platform (GPP) String */
+  gpp: t.StringC; /** Consent Manager View State */
+  viewState: t.KeyofC<{
+    QuickOptions: unknown;
+    QuickOptions3: unknown;
+    AcceptAll: unknown;
+    AcceptAllRejectAllToggle: unknown;
+    AcceptAllOrMoreChoices: unknown;
+    AcceptOrRejectAll: unknown;
+    AcceptOrRejectAllOrMoreChoices: unknown;
+    AcceptOrRejectAnalytics: unknown;
+    AcceptOrRejectAdvertising: unknown;
+    NoticeAndDoNotSell: unknown;
+    DoNotSellExplainer: unknown;
+    CompleteOptionsToggles: unknown;
+    PrivacyPolicyNotice: unknown;
+    PrivacyPolicyNoticeWithCloseButton: unknown;
+    CompleteOptions: unknown;
+    CompleteOptionsInverted: unknown;
+    Hidden: unknown;
+    TCF_EU: unknown;
+    DoNotSellDisclosure: unknown;
+    OptOutDisclosure: unknown;
+    LanguageOptions: unknown;
+    Collapsed: unknown;
+    Closed: unknown;
+  }>; /** Airgap Version */
+  airgapVersion: t.StringC;
+}>;
+declare const FullTrackingConsentDetails: t.IntersectionC<[t.IntersectionC<[t.IntersectionC<[t.TypeC<{
+  /**
+   * Was tracking consent confirmed by the user?
+   * If this is false, the consent was resolved from defaults & is not yet confirmed
+   */
+  confirmed: t.BooleanC; /** Consent resolution/last-modified timestamp (ISO 8601) */
+  timestamp: t.StringC;
+}>, t.PartialC<{
+  /** Has the consent been updated (including no-change confirmation) since default resolution */updated: t.BooleanC;
+  /**
+   * Whether or not the UI has been shown to the end-user (undefined in older versions of airgap.js)
+   * @deprecated It was discovered that this value was not being set reliably in some versions, and was not being used.
+   */
+  prompted: t.BooleanC; /** Arbitrary metadata that customers want to be associated with consent state */
+  metadata: t.IntersectionC<[t.PartialC<{
+    tcmp: t.PartialC<{
+      tcf: t.PartialC<{
+        tcString: t.StringC;
+      }>;
+    }>;
+  }>, t.UnknownRecordC]>; /** When the metadata was last updated */
+  metadataTimestamp: t.StringC;
+}>]>, t.TypeC<{
+  /** Tracking consent config */purposes: t.IntersectionC<[t.PartialC<{
+    Essential: t.LiteralC<true>;
+    Unknown: t.LiteralC<false>;
+  }>, t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+    on: null;
+    off: null;
+  }>]>, t.UndefinedC]>>]>;
+}>]>, t.PartialC<{
+  /** Transparency Consent (TCF) String */tcf: t.StringC; /** US Privacy (USP) String */
+  usp: t.StringC; /** Global Privacy Platform (GPP) String */
+  gpp: t.StringC; /** Consent Manager View State */
+  viewState: t.KeyofC<{
+    QuickOptions: unknown;
+    QuickOptions3: unknown;
+    AcceptAll: unknown;
+    AcceptAllRejectAllToggle: unknown;
+    AcceptAllOrMoreChoices: unknown;
+    AcceptOrRejectAll: unknown;
+    AcceptOrRejectAllOrMoreChoices: unknown;
+    AcceptOrRejectAnalytics: unknown;
+    AcceptOrRejectAdvertising: unknown;
+    NoticeAndDoNotSell: unknown;
+    DoNotSellExplainer: unknown;
+    CompleteOptionsToggles: unknown;
+    PrivacyPolicyNotice: unknown;
+    PrivacyPolicyNoticeWithCloseButton: unknown;
+    CompleteOptions: unknown;
+    CompleteOptionsInverted: unknown;
+    Hidden: unknown;
+    TCF_EU: unknown;
+    DoNotSellDisclosure: unknown;
+    OptOutDisclosure: unknown;
+    LanguageOptions: unknown;
+    Collapsed: unknown;
+    Closed: unknown;
+  }>; /** Airgap Version */
+  airgapVersion: t.StringC;
+}>]>;
+/** Override types. */
+type FullTrackingConsentDetails = t.TypeOf<typeof FullTrackingConsentDetails>;
+declare const FullTrackingConsentDetailsWithNulls: t.IntersectionC<[t.IntersectionC<[t.TypeC<{
+  /**
+   * Was tracking consent confirmed by the user?
+   * If this is false, the consent was resolved from defaults & is not yet confirmed
+   */
+  confirmed: t.BooleanC; /** Consent resolution/last-modified timestamp (ISO 8601) */
+  timestamp: t.StringC;
+}>, t.PartialC<{
+  /** Has the consent been updated (including no-change confirmation) since default resolution */updated: t.BooleanC;
+  /**
+   * Whether or not the UI has been shown to the end-user (undefined in older versions of airgap.js)
+   * @deprecated It was discovered that this value was not being set reliably in some versions, and was not being used.
+   */
+  prompted: t.BooleanC; /** Arbitrary metadata that customers want to be associated with consent state */
+  metadata: t.IntersectionC<[t.PartialC<{
+    tcmp: t.PartialC<{
+      tcf: t.PartialC<{
+        tcString: t.StringC;
+      }>;
+    }>;
+  }>, t.UnknownRecordC]>; /** When the metadata was last updated */
+  metadataTimestamp: t.StringC;
+}>]>, t.PartialC<{
+  /** Transparency Consent (TCF) String */tcf: t.StringC; /** US Privacy (USP) String */
+  usp: t.StringC; /** Global Privacy Platform (GPP) String */
+  gpp: t.StringC; /** Consent Manager View State */
+  viewState: t.KeyofC<{
+    QuickOptions: unknown;
+    QuickOptions3: unknown;
+    AcceptAll: unknown;
+    AcceptAllRejectAllToggle: unknown;
+    AcceptAllOrMoreChoices: unknown;
+    AcceptOrRejectAll: unknown;
+    AcceptOrRejectAllOrMoreChoices: unknown;
+    AcceptOrRejectAnalytics: unknown;
+    AcceptOrRejectAdvertising: unknown;
+    NoticeAndDoNotSell: unknown;
+    DoNotSellExplainer: unknown;
+    CompleteOptionsToggles: unknown;
+    PrivacyPolicyNotice: unknown;
+    PrivacyPolicyNoticeWithCloseButton: unknown;
+    CompleteOptions: unknown;
+    CompleteOptionsInverted: unknown;
+    Hidden: unknown;
+    TCF_EU: unknown;
+    DoNotSellDisclosure: unknown;
+    OptOutDisclosure: unknown;
+    LanguageOptions: unknown;
+    Collapsed: unknown;
+    Closed: unknown;
+  }>; /** Airgap Version */
+  airgapVersion: t.StringC;
+}>, t.TypeC<{
+  /** Tracking consent config */purposes: t.RecordC<t.StringC, t.UnionC<[t.IntersectionC<[t.PartialC<{
+    Essential: t.LiteralC<true>;
+    Unknown: t.LiteralC<false>;
+  }>, t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+    on: null;
+    off: null;
+  }>]>, t.UndefinedC]>>]>, t.NullC]>>;
+}>]>;
+/** Override types. */
+type FullTrackingConsentDetailsWithNulls = t.TypeOf<typeof FullTrackingConsentDetailsWithNulls>;
+declare const ConsentPreferencesBody: t.TypeC<{
+  /** token containing encrypted identifier */token: t.StringC; /** consent partition (defaults to bundle id) */
+  partition: t.StringC; /** user consent */
+  consent: t.IntersectionC<[t.IntersectionC<[t.TypeC<{
+    /**
+     * Was tracking consent confirmed by the user?
+     * If this is false, the consent was resolved from defaults & is not yet confirmed
+     */
+    confirmed: t.BooleanC; /** Consent resolution/last-modified timestamp (ISO 8601) */
+    timestamp: t.StringC;
+  }>, t.PartialC<{
+    /** Has the consent been updated (including no-change confirmation) since default resolution */updated: t.BooleanC;
+    /**
+     * Whether or not the UI has been shown to the end-user (undefined in older versions of airgap.js)
+     * @deprecated It was discovered that this value was not being set reliably in some versions, and was not being used.
+     */
+    prompted: t.BooleanC; /** Arbitrary metadata that customers want to be associated with consent state */
+    metadata: t.IntersectionC<[t.PartialC<{
+      tcmp: t.PartialC<{
+        tcf: t.PartialC<{
+          tcString: t.StringC;
+        }>;
+      }>;
+    }>, t.UnknownRecordC]>; /** When the metadata was last updated */
+    metadataTimestamp: t.StringC;
+  }>]>, t.TypeC<{
+    /** Tracking consent config */purposes: t.IntersectionC<[t.PartialC<{
+      Essential: t.LiteralC<true>;
+      Unknown: t.LiteralC<false>;
+    }>, t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.BooleanC, t.LiteralC<"Auto">, t.LiteralC<"AutoGDPR">, t.LiteralC<"AutoDNT">, t.LiteralC<"AutoGPC">, t.KeyofC<{
+      on: null;
+      off: null;
+    }>]>, t.UndefinedC]>>]>;
+  }>]>;
+}>;
+/** Override types. */
+type ConsentPreferencesBody = t.TypeOf<typeof ConsentPreferencesBody>;
+declare const ConsentTokenPayload: t.IntersectionC<[t.TypeC<{
+  encryptedIdentifier: t.StringC;
+}>, t.PartialC<{
+  deprecatedEncryptedIdentifiers: t.ArrayC<t.StringC>;
+}>]>;
+/** Type override */
+type ConsentTokenPayload = t.TypeOf<typeof ConsentTokenPayload>;
+/** Tracking purpose */
+declare const TrackingPurpose: t.UnionC<[t.KeyofC<{
+  Unknown: "Unknown";
+  Essential: "Essential";
+}>, t.StringC]>;
+/** Type override */
+type TrackingPurpose = t.TypeOf<typeof TrackingPurpose>;
+/** Tracking purposes */
+type TrackingPurposes = Set<TrackingPurpose>;
+/** Tracking consent change diffs */
+declare const ConsentChange: t.RecordC<t.UnionC<[t.KeyofC<{
+  Unknown: "Unknown";
+  Essential: "Essential";
+}>, t.StringC]>, t.BooleanC>;
+/** type overload */
+type ConsentChange = t.TypeOf<typeof ConsentChange>;
+/** Regime purpose scopes configuration */
+declare const RegimePurposeScopesConfig: t.ArrayC<t.BrandC<t.ArrayC<t.ArrayC<t.StringC>>, _transcend_io_type_utils0.FixedLengthArrayBrand<t.ArrayC<t.StringC>>>>;
+/** Type override */
+type RegimePurposeScopesConfig = [/** Regimes */regimes: string[], /** In-scope purposes */purposes: TrackingPurpose[]][];
+/** Request source types */
+type AirgapRequestSource = 'unknown' | 'airgap.js' | 'fetch' | 'xhr' | 'websocket' | 'webtransport' | 'service-worker' | 'shared-worker' | 'worker' | 'module-worker' | 'shared-module-worker' | 'eventsource' | 'beacon' | 'CSPV' | 'navigation' | 'open' | 'script' | AirgapDOMRequestSource;
+/** DOM-initiated request source types */
+type AirgapDOMRequestSource = 'DOM:style' | 'DOM:image' | 'DOM:media' | 'DOM:video' | 'DOM:audio' | 'DOM:track' | 'DOM:link' | 'DOM:form' | 'DOM:form-action' | 'DOM:view' | 'DOM:ping' | 'DOM:unknown';
+/**
+ * Airgap pending request descriptor init dictionary
+ */
+interface PendingRequestInit {
+  /** Request initiator type */
+  type: AirgapRequestSource;
+  /** Request URL */
+  url: Stringifiable;
+  /** Persist request for cross-session replay (false by default) */
+  persist?: boolean;
+  /** Request initialization data */
+  requestInit?: RequestInit;
+  /** Request timestamp (ISO 8601) */
+  timestamp?: Stringifiable;
+  /** Request DOM target */
+  target?: Node | IDynamicNodeReference | null;
+  /** Mutator to apply changes associated with the request */
+  mutator?(): void;
+  /** Serialize request or mutation state back to DOM patcher parser input */
+  serialize?(): any;
+  /** Prevent credentials from being included in request */
+  omitCredentials?(): boolean;
+}
+/** Properties that are added to instantiated PendingRequests */
+interface InstantiatedPendingRequestProps {
+  /** Primary or first associated request URL input */
+  url: Stringifiable;
+  /** All associated request URL inputs */
+  urls: Stringifiable[];
+  /** Request timestamp (ISO 8601) */
+  timestamp: Stringifiable;
+  /** Serialize request or mutation state back to DOM patcher parser input */
+  serialize(): any;
+  /** The following IPendingEvent APIs are only available to overrides: */
+  /**
+   * All associated resolved request URLs. null = invalid URL or data: URL (parsing
+   * skipped to optimize performance)
+   */
+  URLs: (URL | null)[];
+  /** Prevent credentials from being included in request */
+  omitCredentials(): boolean;
+  /** Whether or not request is currently allowed */
+  allowed: boolean;
+  /** Bypass our consent logic and force-allow request */
+  allow(): void;
+  /** Bypass our consent logic and force-deny request */
+  deny(): void;
+  /** Bypass our consent logic to force-deny request and also block it from entering the replay quarantine */
+  block(): void;
+  /** Resolved tracking purposes associated with this pending mutation */
+  purposes: Set<TrackingPurpose>;
+}
+/**
+ * Airgap pending request descriptor with script annotation
+ */
+type PendingRequestDescriptor = PendingRequestInit & InstantiatedPendingRequestProps;
+/** Airgap pending request descriptor init with multiple URLs */
+type PendingMutationInit = Omit<PendingRequestInit, 'url'> & {
+  /** Request URLs */urls: Stringifiable[];
+};
+/** PendingEvent init input */
+type PendingEventInit = PendingRequestInit | PendingMutationInit;
+/** Pending mutation descriptor */
+type PendingMutationDescriptor = PendingMutationInit & InstantiatedPendingRequestProps;
+/** Pending event props that can't or won't be serialized to JSON */
+type PendingEventUnserializableProps = 'persist' | 'target' | 'mutator' | 'serialize' | 'URLs' | 'omitCredentials' | 'allow' | 'deny' | 'purposes' | 'allowed' | 'blocked';
+/** JSON-safe representation of pending event tracking purposes */
+interface PendingEventPurposesJSON {
+  /** Tracking purposes list */
+  purposes?: TrackingPurpose[];
+}
+/** Pending request subset to JSON-safe properties */
+type PendingRequestJSON = Omit<PendingRequestDescriptor, PendingEventUnserializableProps | 'urls'> & PendingEventPurposesJSON;
+/** Pending mutation subset to JSON-safe properties */
+type PendingMutationJSON = Omit<PendingMutationDescriptor, PendingEventUnserializableProps | 'url'> & PendingEventPurposesJSON;
+/** Airgap pending request interface */
+interface IPendingRequest extends PendingRequestDescriptor {
+  /** Convert PendingRequest to JSON-safe representation */
+  toJSON(): PendingRequestJSON;
+}
+/** Airgap pending mutation interface */
+interface IPendingMutation extends PendingMutationDescriptor {
+  /** Convert PendingRequest to JSON-safe representation */
+  toJSON(): PendingMutationJSON;
+}
+/** Pending event descriptor */
+type PendingEventDescriptor = PendingRequestDescriptor | PendingMutationDescriptor;
+/** Pending request or mutation */
+type IPendingEvent = IPendingMutation | IPendingRequest;
+/** Unapproved request queue */
+type PendingRequestQueue = IPendingRequest[];
+/** Unapproved mutation queue */
+type PendingMutationQueue = IPendingEvent[];
+/** Unapproved event queue */
+type PendingEventQueue = IPendingEvent[];
+/** Cookie descriptor */
+interface Cookie {
+  /** Cookie name */
+  name: Stringifiable;
+  /** Cookie value */
+  value?: Stringifiable;
+  /** Cookie change event timestamp (ISO 8601) */
+  timestamp?: string;
+  /** Expiry date (UTC date string or DOMTimeStamp) */
+  expires?: number | Stringifiable;
+  /** Max cookie age (seconds) */
+  maxAge?: number;
+  /** Optional cookie host scope */
+  domain?: Stringifiable;
+  /** Optional cookie path scope */
+  path?: Stringifiable;
+  /** Should cookie only be sent in secure contexts? */
+  secure?: boolean;
+  /**
+   * Should cookie be restricted to the same site?
+   * Values: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite
+   */
+  sameSite?: Stringifiable;
+  /**
+   * Is the cookie partitioned (e.g. by CHIPS)?
+   * See https://developer.mozilla.org/en-US/docs/Web/Privacy/Partitioned_cookies
+   * and https://developer.mozilla.org/en-US/docs/Web/API/CookieStore/get#:~:text=of%20the%20cookie.-,partitioned,-A%20boolean%20indicating
+   */
+  partitioned?: boolean;
+  /** Target document / node */
+  target?: Node | null;
+}
+/**
+ * PendingCookieMutation constructor input
+ */
+interface PendingCookieMutationInit extends Cookie {
+  /** Persist cookie for cross-session replay if quarantined (true by default) */
+  persist?: boolean;
+  /** Mutator to apply cookie mutation */
+  mutator?(): void | Promise<void>;
+}
+/** Properties that are added to instantiated PendingCookieMutations */
+interface InstantiatedPendingCookieMutationProps {
+  /** Expiry date (DOMTimeStamp) */
+  expires?: number;
+  /** Cookie change event timestamp (Date.now() format) */
+  timestamp: string;
+  /** Whether or not cookie is currently allowed. null = passthrough */
+  allowed?: boolean | null;
+  /** Whether or not cookie is currently disallowed & blocked from entering the quarantine */
+  blocked?: boolean;
+  /** Bypass our consent logic and force-allow cookie */
+  allow(): void;
+  /** Bypass our consent logic and force-deny cookie */
+  deny(): void;
+  /** Bypass our consent logic to force-deny cookie and also block it from entering the quarantine */
+  block(): void;
+  /** Resolved tracking purposes associated with this pending mutation */
+  purposes: Set<TrackingPurpose>;
+  /** Mutator to apply cookie mutation */
+  mutator(): void | Promise<void>;
+}
+/** Pending cookie mutation descriptor */
+type PendingCookieMutationDescriptor = Omit<PendingCookieMutationInit, 'expires'> & InstantiatedPendingCookieMutationProps;
+/** Pending cookie mutation props that can't or won't be serialized to JSON */
+type PendingCookieMutationUnserializableProps = 'persist' | 'mutator' | 'allow' | 'deny' | 'purposes' | 'allowed' | 'blocked';
+/** JSON-safe representation of pending cookie mutation tracking purposes */
+interface PendingCookieMutationPurposesJSON {
+  /** Tracking purposes list */
+  purposes?: TrackingPurpose[];
+}
+/** Pending request subset to JSON-safe properties */
+type PendingCookieMutationJSON = Omit<PendingCookieMutationDescriptor, PendingCookieMutationUnserializableProps> & PendingCookieMutationPurposesJSON;
+/** Airgap pending cookie mutation interface */
+interface IPendingCookieMutation extends PendingCookieMutationDescriptor {
+  /** Convert PendingCookieMutation to JSON-safe representation */
+  toJSON(): PendingCookieMutationJSON;
+}
+/** Pending cookie mutation queue */
+type PendingCookieQueue = IPendingCookieMutation[];
+/** Interface for dynamic node references */
+interface IDynamicNodeReference {
+  /**
+   * Current node getter. This should always be used in `handleLiveMutation()`.
+   * @returns current node
+   */
+  getNode(): Element;
+  /**
+   * Live node getter. Use this to apply mutations in `quarantine()`
+   * and `quarantineMutation()` handlers.
+   *
+   * `release()` must always be called after completing
+   * mutations using `getLiveNode()`.
+   * @returns live node
+   */
+  getLiveNode(): Element;
+  /** Release & garbage-collect internal node reference */
+  release(): void;
+}
+//#endregion
+export { AirgapAPI, AirgapAuth, AirgapAuthMap, AirgapConsentEventType, AirgapDOMRequestSource, AirgapEventType, AirgapExportOptions, AirgapQueues, AirgapRequestSource, AirgapSyncType, AirgapSystemStatus, AirgapToggleOptions, AirgapWatcher, AutoOptOut, AutoOptOutForDNT, AutoOptOutForGDPR, AutoOptOutForGPC, BooleanString, ConsentChange, ConsentChangeEventDetails, ConsentChangeEventPayload, ConsentOptions, ConsentPreferencesBody, ConsentTokenPayload, ConsoleSafeLogLevel, Cookie, CookieOverride, CookieWatcher, CoreTrackingConsentDetails, DefaultConsentConfig, DefaultConsentConfigValue, FullTrackingConsentDetails, FullTrackingConsentDetailsWithNulls, GetPurposeTypesOptions, IDynamicNodeReference, IPendingCookieMutation, IPendingEvent, IPendingMutation, IPendingRequest, InstantiatedPendingCookieMutationProps, InstantiatedPendingRequestProps, LogEmitter, LogEntry, LogEntryType, LogItem, LogLevel, LogMessage, LogTag, Logger, Metadata, PendingCookieMutationDescriptor, PendingCookieMutationInit, PendingCookieMutationJSON, PendingCookieQueue, PendingEventDescriptor, PendingEventInit, PendingEventQueue, PendingMutationDescriptor, PendingMutationInit, PendingMutationJSON, PendingMutationQueue, PendingRequestDescriptor, PendingRequestInit, PendingRequestJSON, PendingRequestQueue, PrivacyRegime, RegimePurposeScopesConfig, RegimeToPurposeScopes, Removable, RequestOverride, ReservedMetadata, Stringifiable, SyncOptions, TrackingConsent, TrackingConsentDetails, TrackingConsentOptionalData, TrackingConsentWithNulls, TrackingEventType, TrackingPurpose, TrackingPurposeDetails, TrackingPurposes, TrackingPurposesConfig, TrackingPurposesTypes, UserPrivacySignal };
+//# sourceMappingURL=core.d.mts.map