@transcend-io/airgap.js-types 13.0.1 → 14.0.0

package/dist/index.d.mts

@@ -0,0 +1,2510 @@
+import * as _transcend_io_type_utils0 from "@transcend-io/type-utils";
+import { ObjByString } from "@transcend-io/type-utils";
+import * as t from "io-ts";
+import { IsoCountryCode } from "@transcend-io/privacy-types";
+import { ConsentManagerSupportedTranslationValue, LocaleValue } from "@transcend-io/internationalization";
+
+//#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.BooleanC, t.StringC, t.UndefinedC]>>]>;
+/**
+ * Type override
+ */
+type TrackingConsent = t.TypeOf<typeof TrackingConsent>;
+declare const TrackingConsentWithNulls: t.RecordC<t.StringC, t.UnionC<[t.BooleanC, 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.BooleanC, t.StringC, 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.BooleanC, t.StringC, 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.BooleanC, 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.BooleanC, t.StringC, 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
+//#region src/iab.d.ts
+/**
+ * TCF purpose configuration
+ */
+declare const TcfPurpose: t.TypeC<{
+  id: t.NumberC;
+  name: t.StringC;
+  description: t.StringC;
+  descriptionLegal: t.StringC;
+}>;
+/**
+ * Type override
+ */
+type TcfPurpose = t.TypeOf<typeof TcfPurpose>;
+/**
+ * TCF stack configuration
+ */
+declare const TcfStack: t.TypeC<{
+  id: t.NumberC;
+  purposes: t.ArrayC<t.NumberC>;
+  specialFeatures: t.ArrayC<t.NumberC>;
+  name: t.StringC;
+  description: t.StringC;
+}>;
+/**
+ * Type override
+ */
+type TcfStack = t.TypeOf<typeof TcfStack>;
+/**
+ * TCF stack configuration
+ */
+declare const TcfVendor: t.IntersectionC<[t.TypeC<{
+  id: t.NumberC;
+  name: t.StringC;
+  purposes: t.ArrayC<t.NumberC>;
+  legIntPurposes: t.ArrayC<t.NumberC>;
+  flexiblePurposes: t.ArrayC<t.NumberC>;
+  specialPurposes: t.ArrayC<t.NumberC>;
+  features: t.ArrayC<t.NumberC>;
+  specialFeatures: t.ArrayC<t.NumberC>;
+  policyUrl: t.StringC;
+  cookieMaxAgeSeconds: t.UnionC<[t.NumberC, t.NullC]>;
+  usesCookies: t.BooleanC;
+}>, t.PartialC<{
+  deletedDate: t.StringC;
+  overflow: t.TypeC<{
+    httpGetLimit: t.NumberC;
+  }>;
+  cookieRefresh: t.BooleanC;
+  usesNonCookieAccess: t.BooleanC;
+  deviceStorageDisclosureUrl: t.StringC;
+}>]>;
+/**
+ * Type override
+ */
+type TcfVendor = t.TypeOf<typeof TcfVendor>;
+declare const TcfVendorListVersion: t.TypeC<{
+  gvlSpecificationVersion: t.NumberC;
+  vendorListVersion: t.NumberC;
+  tcfPolicyVersion: t.NumberC;
+  lastUpdated: t.StringC;
+}>;
+/**
+ * Type override
+ */
+type TcfVendorListVersion = t.TypeOf<typeof TcfVendorListVersion>;
+/**
+ * TCF global vendor list version 2
+ */
+declare const TcfV2VendorList: t.IntersectionC<[t.TypeC<{
+  gvlSpecificationVersion: t.NumberC;
+  vendorListVersion: t.NumberC;
+  tcfPolicyVersion: t.NumberC;
+  lastUpdated: t.StringC;
+}>, t.TypeC<{
+  purposes: t.RecordC<t.StringC, t.TypeC<{
+    id: t.NumberC;
+    name: t.StringC;
+    description: t.StringC;
+    descriptionLegal: t.StringC;
+  }>>;
+  specialPurposes: t.RecordC<t.StringC, t.TypeC<{
+    id: t.NumberC;
+    name: t.StringC;
+    description: t.StringC;
+    descriptionLegal: t.StringC;
+  }>>;
+  features: t.RecordC<t.StringC, t.TypeC<{
+    id: t.NumberC;
+    name: t.StringC;
+    description: t.StringC;
+    descriptionLegal: t.StringC;
+  }>>;
+  specialFeatures: t.RecordC<t.StringC, t.TypeC<{
+    id: t.NumberC;
+    name: t.StringC;
+    description: t.StringC;
+    descriptionLegal: t.StringC;
+  }>>;
+  stacks: t.RecordC<t.StringC, t.TypeC<{
+    id: t.NumberC;
+    purposes: t.ArrayC<t.NumberC>;
+    specialFeatures: t.ArrayC<t.NumberC>;
+    name: t.StringC;
+    description: t.StringC;
+  }>>;
+  vendors: t.RecordC<t.StringC, t.IntersectionC<[t.TypeC<{
+    id: t.NumberC;
+    name: t.StringC;
+    purposes: t.ArrayC<t.NumberC>;
+    legIntPurposes: t.ArrayC<t.NumberC>;
+    flexiblePurposes: t.ArrayC<t.NumberC>;
+    specialPurposes: t.ArrayC<t.NumberC>;
+    features: t.ArrayC<t.NumberC>;
+    specialFeatures: t.ArrayC<t.NumberC>;
+    policyUrl: t.StringC;
+    cookieMaxAgeSeconds: t.UnionC<[t.NumberC, t.NullC]>;
+    usesCookies: t.BooleanC;
+  }>, t.PartialC<{
+    deletedDate: t.StringC;
+    overflow: t.TypeC<{
+      httpGetLimit: t.NumberC;
+    }>;
+    cookieRefresh: t.BooleanC;
+    usesNonCookieAccess: t.BooleanC;
+    deviceStorageDisclosureUrl: t.StringC;
+  }>]>>;
+}>]>;
+/**
+ * Overload TcfV2VendorList as a type
+ */
+type TcfV2VendorList = t.TypeOf<typeof TcfV2VendorList>;
+/**
+ * TCF GVL v3 purpose configuration (TCF features share the same type)
+ */
+declare const TcfGvlV3Purpose: t.TypeC<{
+  id: t.NumberC;
+  name: t.StringC;
+  description: t.StringC;
+  illustrations: t.ArrayC<t.StringC>;
+}>;
+/**
+ * Type override
+ */
+type TcfGvlV3Purpose = t.TypeOf<typeof TcfGvlV3Purpose>;
+/**
+ * TCF GVL v3 data categories configuration
+ */
+declare const TcfGvlV3DataCategory: t.TypeC<{
+  id: t.NumberC;
+  name: t.StringC;
+  description: t.StringC;
+}>;
+/**
+ * Type override
+ */
+type TcfGvlV3DataCategory = t.TypeOf<typeof TcfGvlV3DataCategory>;
+/**
+ * TCF GVL v3 URL configuration
+ */
+declare const TcfGvlV3Url: t.IntersectionC<[t.TypeC<{
+  langId: t.StringC;
+  privacy: t.StringC;
+}>, t.PartialC<{
+  legIntClaim: t.StringC;
+}>]>;
+/**
+ * Type override
+ */
+type TcfGvlV3Url = t.TypeOf<typeof TcfGvlV3Url>;
+/**
+ * TCF GVL v3 data retention configuration
+ */
+declare const TcfGvlV3DataRetention: t.IntersectionC<[t.TypeC<{
+  purposes: t.RecordC<t.StringC, t.NumberC>;
+  specialPurposes: t.RecordC<t.StringC, t.NumberC>;
+}>, t.PartialC<{
+  stdRetention: t.UnionC<[t.NumberC, t.NullC]>;
+}>]>;
+/**
+ * Type override
+ */
+type TcfGvlV3DataRetention = t.TypeOf<typeof TcfGvlV3DataRetention>;
+/**
+ * TCF GVL v3 vendor configuration
+ */
+declare const TcfGvlV3Vendor: t.IntersectionC<[t.TypeC<{
+  id: t.NumberC;
+  name: t.StringC;
+  purposes: t.ArrayC<t.NumberC>;
+  legIntPurposes: t.ArrayC<t.NumberC>;
+  flexiblePurposes: t.ArrayC<t.NumberC>;
+  specialPurposes: t.ArrayC<t.NumberC>;
+  features: t.ArrayC<t.NumberC>;
+  specialFeatures: t.ArrayC<t.NumberC>;
+  cookieMaxAgeSeconds: t.UnionC<[t.NumberC, t.NullC]>;
+  usesCookies: t.BooleanC;
+  cookieRefresh: t.BooleanC;
+  usesNonCookieAccess: t.BooleanC;
+  dataRetention: t.IntersectionC<[t.TypeC<{
+    purposes: t.RecordC<t.StringC, t.NumberC>;
+    specialPurposes: t.RecordC<t.StringC, t.NumberC>;
+  }>, t.PartialC<{
+    stdRetention: t.UnionC<[t.NumberC, t.NullC]>;
+  }>]>;
+  urls: t.ArrayC<t.IntersectionC<[t.TypeC<{
+    langId: t.StringC;
+    privacy: t.StringC;
+  }>, t.PartialC<{
+    legIntClaim: t.StringC;
+  }>]>>;
+  deviceStorageDisclosureUrl: t.StringC;
+}>, t.PartialC<{
+  deletedDate: t.StringC;
+  overflow: t.TypeC<{
+    httpGetLimit: t.NumberC;
+  }>;
+  dataDeclaration: t.ArrayC<t.NumberC>;
+}>]>;
+/**
+ * Type override
+ */
+type TcfGvlV3Vendor = t.TypeOf<typeof TcfGvlV3Vendor>;
+/**
+ * TCF global vendor list version 3
+ */
+declare const TcfV3VendorList: t.IntersectionC<[t.TypeC<{
+  gvlSpecificationVersion: t.NumberC;
+  vendorListVersion: t.NumberC;
+  tcfPolicyVersion: t.NumberC;
+  lastUpdated: t.StringC;
+}>, t.TypeC<{
+  purposes: t.RecordC<t.StringC, t.TypeC<{
+    id: t.NumberC;
+    name: t.StringC;
+    description: t.StringC;
+    illustrations: t.ArrayC<t.StringC>;
+  }>>;
+  specialPurposes: t.RecordC<t.StringC, t.TypeC<{
+    id: t.NumberC;
+    name: t.StringC;
+    description: t.StringC;
+    illustrations: t.ArrayC<t.StringC>;
+  }>>;
+  features: t.RecordC<t.StringC, t.TypeC<{
+    id: t.NumberC;
+    name: t.StringC;
+    description: t.StringC;
+    illustrations: t.ArrayC<t.StringC>;
+  }>>;
+  specialFeatures: t.RecordC<t.StringC, t.TypeC<{
+    id: t.NumberC;
+    name: t.StringC;
+    description: t.StringC;
+    illustrations: t.ArrayC<t.StringC>;
+  }>>;
+  stacks: t.RecordC<t.StringC, t.TypeC<{
+    id: t.NumberC;
+    purposes: t.ArrayC<t.NumberC>;
+    specialFeatures: t.ArrayC<t.NumberC>;
+    name: t.StringC;
+    description: t.StringC;
+  }>>;
+  dataCategories: t.RecordC<t.StringC, t.TypeC<{
+    id: t.NumberC;
+    name: t.StringC;
+    description: t.StringC;
+  }>>;
+  vendors: t.RecordC<t.StringC, t.IntersectionC<[t.TypeC<{
+    id: t.NumberC;
+    name: t.StringC;
+    purposes: t.ArrayC<t.NumberC>;
+    legIntPurposes: t.ArrayC<t.NumberC>;
+    flexiblePurposes: t.ArrayC<t.NumberC>;
+    specialPurposes: t.ArrayC<t.NumberC>;
+    features: t.ArrayC<t.NumberC>;
+    specialFeatures: t.ArrayC<t.NumberC>;
+    cookieMaxAgeSeconds: t.UnionC<[t.NumberC, t.NullC]>;
+    usesCookies: t.BooleanC;
+    cookieRefresh: t.BooleanC;
+    usesNonCookieAccess: t.BooleanC;
+    dataRetention: t.IntersectionC<[t.TypeC<{
+      purposes: t.RecordC<t.StringC, t.NumberC>;
+      specialPurposes: t.RecordC<t.StringC, t.NumberC>;
+    }>, t.PartialC<{
+      stdRetention: t.UnionC<[t.NumberC, t.NullC]>;
+    }>]>;
+    urls: t.ArrayC<t.IntersectionC<[t.TypeC<{
+      langId: t.StringC;
+      privacy: t.StringC;
+    }>, t.PartialC<{
+      legIntClaim: t.StringC;
+    }>]>>;
+    deviceStorageDisclosureUrl: t.StringC;
+  }>, t.PartialC<{
+    deletedDate: t.StringC;
+    overflow: t.TypeC<{
+      httpGetLimit: t.NumberC;
+    }>;
+    dataDeclaration: t.ArrayC<t.NumberC>;
+  }>]>>;
+}>]>;
+/**
+ * Type override
+ */
+type TcfV3VendorList = t.TypeOf<typeof TcfV3VendorList>;
+declare const NonTcfVendor: t.IntersectionC<[t.TypeC<{
+  /** The vendor name */name: t.StringC; /** The transcend purposes associated with each vendor */
+  purposes: t.ArrayC<t.StringC>;
+}>, t.PartialC<{
+  /** The vendor description */description: t.StringC; /** The privacy policy URL */
+  privacyPolicyUrl: t.StringC;
+}>]>;
+/**
+ * Type override
+ */
+type NonTcfVendor = t.TypeOf<typeof NonTcfVendor>;
+//#endregion
+//#region src/enums/purpose.d.ts
+/**
+ * The options for the type of purpose that airgap classifies requests into
+ */
+declare const SpecialTrackingPurpose: {
+  /** The request has an unknown tracking purpose */Unknown: "Unknown"; /** The request is necessary for the essential features of the website */
+  Essential: "Essential";
+};
+/** Type override */
+type SpecialTrackingPurpose = (typeof SpecialTrackingPurpose)[keyof typeof SpecialTrackingPurpose];
+/**
+ * Possible values for the default consent that can be given to a tracking purpose
+ */
+declare const DefaultConsentValue: {
+  /** Tracking purpose is NOT consented to by default */Off: "off";
+  /**
+   * Tracking purpose is consented to by default, unless user is protected by GDPR
+   * or has DNT or GPC enabled
+   */
+  Auto: "Auto";
+};
+/** Type override */
+type DefaultConsentValue = (typeof DefaultConsentValue)[keyof typeof DefaultConsentValue];
+/**
+ * Purposes that can be configured
+ */
+declare const ConfigurablePurpose: {
+  /** SaaS tools used for advertising purposes */Advertising: "Advertising"; /** SaaS tools used for analytics purposes */
+  Analytics: "Analytics"; /** SaaS tools used for functional purposes */
+  Functional: "Functional"; /** SaaS tools used for selling personal information */
+  SaleOfInfo: "SaleOfInfo";
+};
+/** Type override */
+type ConfigurablePurpose = (typeof ConfigurablePurpose)[keyof typeof ConfigurablePurpose];
+/**
+ * Purposes that can be configured
+ */
+declare const KnownDefaultPurpose: {
+  /** SaaS tools used for advertising purposes */Advertising: "Advertising"; /** SaaS tools used for analytics purposes */
+  Analytics: "Analytics"; /** SaaS tools used for functional purposes */
+  Functional: "Functional"; /** SaaS tools used for selling personal information */
+  SaleOfInfo: "SaleOfInfo"; /** The request is necessary for the essential features of the website */
+  Essential: "Essential";
+};
+/** Type override */
+type KnownDefaultPurpose = (typeof KnownDefaultPurpose)[keyof typeof KnownDefaultPurpose];
+/**
+ * Purposes used by the purpose map
+ */
+declare const Purpose: {
+  /** SaaS tools used for advertising purposes */Advertising: "Advertising"; /** SaaS tools used for analytics purposes */
+  Analytics: "Analytics"; /** SaaS tools used for functional purposes */
+  Functional: "Functional"; /** SaaS tools used for selling personal information */
+  SaleOfInfo: "SaleOfInfo"; /** The request has an unknown tracking purpose */
+  Unknown: "Unknown"; /** The request is necessary for the essential features of the website */
+  Essential: "Essential";
+};
+/** Type override */
+type Purpose = (typeof Purpose)[keyof typeof Purpose];
+/** User-configurable user agent privacy signal */
+declare const UserPrivacySignalEnum: {
+  /** Global Privacy Control */GPC: "GPC"; /** Do Not Track */
+  DNT: "DNT";
+};
+/**
+ * Type override
+ */
+type UserPrivacySignalEnum = (typeof UserPrivacySignalEnum)[keyof typeof UserPrivacySignalEnum];
+//#endregion
+//#region src/enums/privacyRegime.d.ts
+/**
+ * Potentially applicable data privacy legal regimes
+ * NOTE: Please make sure that new entries are compatible with GraphQL Enums
+ */
+declare enum PrivacyRegimeEnum {
+  /** Unable to determine any applicable regimes */
+  Unknown = "Unknown",
+  /** California Privacy Rights Act (and CCPA: California Consumer Privacy Act) */
+  CPRA = "CPRA",
+  /** EU General Data Protection Regulation */
+  GDPR = "GDPR",
+  /** Brazil Lei Geral de Proteção de Dados (General Personal Data Protection Law) */
+  LGPD = "LGPD",
+  /** Virginia Consumer Data Protection Act */
+  CDPA = "CDPA",
+  /** Colorado Privacy Act */
+  CPA = "CPA",
+  /** Nevada Senate Bill 220 */
+  NEVADA_SB220 = "NEVADA_SB220",
+  /** Switzerland New Federal Act on Data Protection */
+  nFADP = "nFADP",
+  /** US Do Not Sell/Share */
+  US_DNSS = "US_DNSS"
+}
+//#endregion
+//#region src/enums/viewState.d.ts
+/**
+ * Consent Manager view state for the Interactive Advertising Bureau
+ */
+declare const IABViewState: {
+  /** Transparency and Consent Framework for Europe */TCF_EU: "TCF_EU";
+};
+/**
+ * View States for Transcend's Consent Manager UI
+ */
+declare const InitialTranscendViewState: {
+  /** expanded and showing quick select options */QuickOptions: "QuickOptions"; /** three option UI: essential, functional/analytics, advertising */
+  QuickOptions3: "QuickOptions3"; /** accept all button call to action, with more options in the banner footer */
+  AcceptAll: "AcceptAll"; /** toggle button that toggles on or off all active purposes in the current regime */
+  AcceptAllRejectAllToggle: "AcceptAllRejectAllToggle"; /** accept all or more options, both as calls to action */
+  AcceptAllOrMoreChoices: "AcceptAllOrMoreChoices"; /** accept all or reject all */
+  AcceptOrRejectAll: "AcceptOrRejectAll"; /** accept all or reject all or more options */
+  AcceptOrRejectAllOrMoreChoices: "AcceptOrRejectAllOrMoreChoices"; /** accept or reject the Analytics script tag */
+  AcceptOrRejectAnalytics: "AcceptOrRejectAnalytics"; /** accept or reject the Advertising script tag */
+  AcceptOrRejectAdvertising: "AcceptOrRejectAdvertising"; /** data collection notice with do not sell */
+  NoticeAndDoNotSell: "NoticeAndDoNotSell"; /** open a modal that allows for an explanation of do not sell/share, before opting out */
+  DoNotSellExplainer: "DoNotSellExplainer"; /** open a modal that allows for complete options toggling */
+  CompleteOptionsToggles: "CompleteOptionsToggles"; /** open a modal that shows a notice that the privacy policy has changed, without any prompt to change consent */
+  PrivacyPolicyNotice: "PrivacyPolicyNotice";
+  /**
+   * open a modal that shows a notice that the privacy policy has changed, without any prompt to change consent
+   * and no button to close the modal. instead there is an X in the top right corner of the modal
+   */
+  PrivacyPolicyNoticeWithCloseButton: "PrivacyPolicyNoticeWithCloseButton"; /** expanded and showing full checkbox options */
+  CompleteOptions: "CompleteOptions"; /** complete options, but selecting a checkbox means the user is opted out */
+  CompleteOptionsInverted: "CompleteOptionsInverted"; /** hidden */
+  Hidden: "Hidden";
+};
+/**
+ * Type override
+ */
+type InitialTranscendViewState = (typeof InitialTranscendViewState)[keyof typeof InitialTranscendViewState];
+/**
+ * Consent Manager view states that can be used at launch
+ */
+declare const InitialViewState: {
+  /** Transparency and Consent Framework for Europe */TCF_EU: "TCF_EU"; /** expanded and showing quick select options */
+  QuickOptions: "QuickOptions"; /** three option UI: essential, functional/analytics, advertising */
+  QuickOptions3: "QuickOptions3"; /** accept all button call to action, with more options in the banner footer */
+  AcceptAll: "AcceptAll"; /** toggle button that toggles on or off all active purposes in the current regime */
+  AcceptAllRejectAllToggle: "AcceptAllRejectAllToggle"; /** accept all or more options, both as calls to action */
+  AcceptAllOrMoreChoices: "AcceptAllOrMoreChoices"; /** accept all or reject all */
+  AcceptOrRejectAll: "AcceptOrRejectAll"; /** accept all or reject all or more options */
+  AcceptOrRejectAllOrMoreChoices: "AcceptOrRejectAllOrMoreChoices"; /** accept or reject the Analytics script tag */
+  AcceptOrRejectAnalytics: "AcceptOrRejectAnalytics"; /** accept or reject the Advertising script tag */
+  AcceptOrRejectAdvertising: "AcceptOrRejectAdvertising"; /** data collection notice with do not sell */
+  NoticeAndDoNotSell: "NoticeAndDoNotSell"; /** open a modal that allows for an explanation of do not sell/share, before opting out */
+  DoNotSellExplainer: "DoNotSellExplainer"; /** open a modal that allows for complete options toggling */
+  CompleteOptionsToggles: "CompleteOptionsToggles"; /** open a modal that shows a notice that the privacy policy has changed, without any prompt to change consent */
+  PrivacyPolicyNotice: "PrivacyPolicyNotice";
+  /**
+   * open a modal that shows a notice that the privacy policy has changed, without any prompt to change consent
+   * and no button to close the modal. instead there is an X in the top right corner of the modal
+   */
+  PrivacyPolicyNoticeWithCloseButton: "PrivacyPolicyNoticeWithCloseButton"; /** expanded and showing full checkbox options */
+  CompleteOptions: "CompleteOptions"; /** complete options, but selecting a checkbox means the user is opted out */
+  CompleteOptionsInverted: "CompleteOptionsInverted"; /** hidden */
+  Hidden: "Hidden";
+};
+/**
+ * Type override
+ */
+type InitialViewState = (typeof InitialViewState)[keyof typeof InitialViewState];
+/**
+ * View states that are displayed in response to a user request (e.g. transcend.doNotSell() or )
+ */
+declare const ResponseViewState: {
+  /** notice that do not sell has been acknowledged properly */DoNotSellDisclosure: "DoNotSellDisclosure"; /** notice of a 1 click opt out for multiple consent purposes */
+  OptOutDisclosure: "OptOutDisclosure";
+};
+/**
+ * Type override
+ */
+type ResponseViewState = (typeof ResponseViewState)[keyof typeof ResponseViewState];
+/**
+ * Consent Manager view states that can be navigated to after initial view state
+ */
+declare const DeepViewState: {
+  /** language options */LanguageOptions: "LanguageOptions";
+};
+/**
+ * Type override
+ */
+type DeepViewState = (typeof DeepViewState)[keyof typeof DeepViewState];
+/**
+ * Consent Manager view states after it's been dismissed
+ */
+declare const DismissedViewState: {
+  /** showing and collapsed */Collapsed: "Collapsed"; /** closed */
+  Closed: "Closed";
+};
+/**
+ * Type override
+ */
+type DismissedViewState = (typeof DismissedViewState)[keyof typeof DismissedViewState];
+/**
+ * All possible view states of the Consent Manager
+ */
+declare const ViewState: {
+  /** showing and collapsed */Collapsed: "Collapsed"; /** closed */
+  Closed: "Closed"; /** language options */
+  LanguageOptions: "LanguageOptions"; /** notice that do not sell has been acknowledged properly */
+  DoNotSellDisclosure: "DoNotSellDisclosure"; /** notice of a 1 click opt out for multiple consent purposes */
+  OptOutDisclosure: "OptOutDisclosure"; /** Transparency and Consent Framework for Europe */
+  TCF_EU: "TCF_EU"; /** expanded and showing quick select options */
+  QuickOptions: "QuickOptions"; /** three option UI: essential, functional/analytics, advertising */
+  QuickOptions3: "QuickOptions3"; /** accept all button call to action, with more options in the banner footer */
+  AcceptAll: "AcceptAll"; /** toggle button that toggles on or off all active purposes in the current regime */
+  AcceptAllRejectAllToggle: "AcceptAllRejectAllToggle"; /** accept all or more options, both as calls to action */
+  AcceptAllOrMoreChoices: "AcceptAllOrMoreChoices"; /** accept all or reject all */
+  AcceptOrRejectAll: "AcceptOrRejectAll"; /** accept all or reject all or more options */
+  AcceptOrRejectAllOrMoreChoices: "AcceptOrRejectAllOrMoreChoices"; /** accept or reject the Analytics script tag */
+  AcceptOrRejectAnalytics: "AcceptOrRejectAnalytics"; /** accept or reject the Advertising script tag */
+  AcceptOrRejectAdvertising: "AcceptOrRejectAdvertising"; /** data collection notice with do not sell */
+  NoticeAndDoNotSell: "NoticeAndDoNotSell"; /** open a modal that allows for an explanation of do not sell/share, before opting out */
+  DoNotSellExplainer: "DoNotSellExplainer"; /** open a modal that allows for complete options toggling */
+  CompleteOptionsToggles: "CompleteOptionsToggles"; /** open a modal that shows a notice that the privacy policy has changed, without any prompt to change consent */
+  PrivacyPolicyNotice: "PrivacyPolicyNotice";
+  /**
+   * open a modal that shows a notice that the privacy policy has changed, without any prompt to change consent
+   * and no button to close the modal. instead there is an X in the top right corner of the modal
+   */
+  PrivacyPolicyNoticeWithCloseButton: "PrivacyPolicyNoticeWithCloseButton"; /** expanded and showing full checkbox options */
+  CompleteOptions: "CompleteOptions"; /** complete options, but selecting a checkbox means the user is opted out */
+  CompleteOptionsInverted: "CompleteOptionsInverted"; /** hidden */
+  Hidden: "Hidden";
+};
+/**
+ * Type override
+ */
+type ViewState = (typeof ViewState)[keyof typeof ViewState];
+//#endregion
+//#region src/enums/browserLanguage.d.ts
+declare const BrowserLanguage: {
+  '(Afan)/Oromoor/Oriya': "om";
+  Abkhazian: "ab";
+  Afar: "aa";
+  Afrikaans: "af";
+  Akan: "ak";
+  Albanian: "sq";
+  Amharic: "am";
+  Arabic: "ar";
+  'Arabic (Algeria)': "ar-DZ";
+  'Arabic (Bahrain)': "ar-BH";
+  'Arabic (Egypt)': "ar-EG";
+  'Arabic (Iraq)': "ar-IQ";
+  'Arabic (Jordan)': "ar-JO";
+  'Arabic (Kuwait)': "ar-KW";
+  'Arabic (Lebanon)': "ar-LB";
+  'Arabic (Morocco)': "ar-MA";
+  'Arabic (Oman)': "ar-OM";
+  'Arabic (Qatar)': "ar-QA";
+  'Arabic (Saudi Arabia)': "ar-SA";
+  'Arabic (Syria)': "ar-SY";
+  'Arabic (Tunisia)': "ar-TN";
+  'Arabic (U.A.E.)': "ar-AE";
+  'Arabic (Yemen)': "ar-YE";
+  'Arabic (libya)': "ar-LY";
+  Aragonese: "an";
+  Armenian: "hy";
+  Assamese: "as";
+  Avaric: "av";
+  Avestan: "ae";
+  Aymara: "ay";
+  Azeri: "az";
+  Bambara: "bm";
+  Bashkir: "ba";
+  Basque: "eu";
+  Belarusian: "be";
+  Bengali: "bn";
+  Bhutani: "dz";
+  Bihari: "bh";
+  Bislama: "bi";
+  Bosnian: "bs";
+  Breton: "br";
+  'Bulgarian (Bulgaria)': "bg-BG";
+  Bulgarian: "bg";
+  Burmese: "my";
+  Cambodian: "km";
+  Catalan: "ca";
+  Chamorro: "ch";
+  Chechen: "ce";
+  Chinese: "zh";
+  'Chinese (China)': "zh-CN";
+  'Chinese (Hong Kong SAR)': "zh-HK";
+  'Chinese (Macau SAR)': "zh-MO";
+  'Chinese (Singapore)': "zh-SG";
+  'Chinese (Simplified)': "zh-Hans";
+  'Chinese (Taiwan)': "zh-TW";
+  Chichewa: "ny";
+  'Church Slavonic': "cu";
+  Cornish: "kw";
+  Corsican: "co";
+  Cree: "cr";
+  'Croatian (Bosnia and Herzegovina)': "hr-BA";
+  'Croatian (Croatia)': "hr-HR";
+  Croatian: "hr";
+  'Czech (Czech Republic)': "cs-CZ";
+  Czech: "cs";
+  Danish: "da";
+  'Danish (Denmark)': "da-DK";
+  Divehi: "div";
+  DivehiDv: "dv";
+  Dutch: "nl";
+  'Dutch (Belgium)': "nl-BE";
+  'Dutch (Netherlands)': "nl-NL";
+  English: "us";
+  'English (Australia)': "en-AU";
+  'English (Belize)': "en-BZ";
+  'English (Canada)': "en-CA";
+  'English (Caribbean)': "en-CB";
+  'English (Ireland)': "en-IE";
+  'English (Jamaica)': "en-JM";
+  'English (New Zealand)': "en-NZ";
+  'English (Philippines)': "en-PH";
+  'English (South Africa)': "en-ZA";
+  'English (Switzerland)': "en-CH";
+  'English (Trinidad)': "en-TT";
+  'English (United Kingdom)': "en-GB";
+  'English (United States)': "en-US";
+  'English (Zimbabwe)': "en-ZW";
+  Esperanto: "eo";
+  Estonian: "et";
+  'Estonian (Estonia)': "et-EE";
+  Ewe: "ee";
+  Faeroese: "fo";
+  Farsi: "fa";
+  Fiji: "fj";
+  Finnish: "fi";
+  'Finnish (Finland)': "fi-FI";
+  French: "fr";
+  'French (Belgium)': "fr-BE";
+  'French (Canada)': "fr-CA";
+  'French (France)': "fr-FR";
+  'French (Luxembourg)': "fr-LU";
+  'French (Monaco)': "fr-MC";
+  'French (Switzerland)': "fr-CH";
+  Frisian: "fy";
+  'FYRO Macedonian': "mk";
+  Gaelic: "gd";
+  Galician: "gl";
+  Ganda: "lg";
+  Georgian: "ka";
+  German: "de";
+  'German (Austria)': "de-AT";
+  'German (Germany)': "de-DE";
+  'German (Liechtenstein)': "de-LI";
+  'German (Luxembourg)': "de-LU";
+  'German (Switzerland)': "de-CH";
+  Greek: "el";
+  'Greek (Greece)': "el-GR";
+  Greenlandic: "kl";
+  Guarani: "gn";
+  Gujarati: "gu";
+  Haitian: "ht";
+  Hausa: "ha";
+  Hebrew: "iw";
+  'Hebrew (Israel)': "he-IL";
+  'Hebrew (Modern)': "he";
+  Herero: "hz";
+  Hindi: "hi";
+  'Hiri Motu': "ho";
+  Hungarian: "hu";
+  'Hungarian (Hungary)': "hu-HU";
+  Icelandic: "is";
+  'Icelandic (Iceland)': "is-IS";
+  Igbo: "ig";
+  Ido: "io";
+  Indonesian: "in";
+  'Indonesian (Modern)': "id";
+  Interlingua: "ia";
+  Interlingue: "ie";
+  Inuktitut: "iu";
+  Inupiak: "ik";
+  Irish: "ga";
+  'Irish (Ireland)': "ga-IE";
+  Italian: "it";
+  'Italian (Italy)': "it-IT";
+  'Italian (Switzerland)': "it-CH";
+  Japanese: "ja";
+  Javanese: "jw";
+  Kannada: "kn";
+  Kanuri: "kr";
+  Kashmiri: "ks";
+  Kazakh: "kk";
+  Kikuyu: "ki";
+  Kinyarwanda: "rw";
+  Kirghiz: "ky";
+  Kirundi: "rn";
+  Kongo: "kg";
+  Konkani: "kok";
+  Korean: "ko";
+  Komi: "kv";
+  Kuanyama: "kj";
+  Kurdish: "ku";
+  Kyrgyz: "kz";
+  Laothian: "lo";
+  Latin: "la";
+  Latvian: "lv";
+  'Latvian (Latvia)': "lv-LV";
+  Limburgan: "li";
+  Lingala: "ln";
+  'Lithuanian (Lithuania)': "lt-LT";
+  Lithuanian: "lt";
+  'Luba-Katanga': "lu";
+  Luxembourgish: "lb";
+  Malagasy: "mg";
+  Malay: "ms";
+  'Malay (Brunei Darussalam)': "ms-BN";
+  'Malay (Malaysia)': "ms-MY";
+  Malayalam: "ml";
+  Maltese: "mt";
+  'Maltese (Malta)': "mt-MT";
+  Manx: "gv";
+  Maori: "mi";
+  Marathi: "mr";
+  Marshallese: "mh";
+  Moldavian: "mo";
+  Mongolian: "mn";
+  Nauru: "na";
+  Navajo: "nv";
+  Ndonga: "ng";
+  'Nepali (India)': "ne";
+  'North Ndebele': "nd";
+  'Northern Sotho': "ns";
+  Norwegian: "no";
+  'Norwegian (Norway)': "no-NO";
+  'Norwegian Bokm\u00E5l': "nb";
+  'Norwegian Bokm\u00E5l (Norway)': "nb-NO";
+  'Norwegian Nynorsk': "nn";
+  'Norwegian Nynorsk (Norway)': "nn-NO";
+  'South Ndebele': "nr";
+  Occitan: "oc";
+  Ojibwa: "oj";
+  Oriya: "or";
+  Ossetian: "os";
+  Pali: "pi";
+  'Pashto/Pushto': "ps";
+  Polish: "pl";
+  'Polish (Poland)': "pl-PL";
+  Portuguese: "pt";
+  'Portuguese (Brazil)': "pt-BR";
+  'Portuguese (Portugal)': "pt-PT";
+  'Portuguese (Switzerland)': "pt-CH";
+  Punjabi: "pa";
+  Quechua: "qu";
+  'Quechua (Bolivia)': "qu-BO";
+  'Quechua (Ecuador)': "qu-EC";
+  'Quechua (Peru)': "qu-PE";
+  'Rhaeto-Romanic': "rm";
+  Romanian: "ro";
+  'Romanian (Moldova)': "ro-MD";
+  'Romanian (Romania)': "ro-RO";
+  Russian: "ru";
+  'Russian (Moldova)': "ru-MD";
+  Sami: "se";
+  'Sami (Finland)': "se-FI";
+  'Sami (Norway)': "se-NO";
+  'Sami (Sweden)': "se-SE";
+  Samoan: "sm";
+  Sango: "sg";
+  Sanskrit: "sa";
+  Sardinian: "sc";
+  Serbian: "sr";
+  'Serbian (Bosnia and Herzegovina)': "sr-BA";
+  'Serbian (Serbia and Montenegro)': "sr-SP";
+  'Serbo-Croatian': "sh";
+  Sesotho: "st";
+  Shona: "sn";
+  'Sichuan Yi': "ii";
+  Sindhi: "sd";
+  Singhalese: "si";
+  Siswati: "ss";
+  Slovak: "sk";
+  'Slovak (Slovakia)': "sk-SK";
+  Slovenian: "sl";
+  'Slovenian (Slovenia)': "sl-SI";
+  Somali: "so";
+  Sorbian: "sb";
+  Spanish: "es";
+  'Spanish (Argentina)': "es-AR";
+  'Spanish (Bolivia)': "es-BO";
+  'Spanish (Chile)': "es-CL";
+  'Spanish (Colombia)': "es-CO";
+  'Spanish (Costa Rica)': "es-CR";
+  'Spanish (Dominican Republic)': "es-DO";
+  'Spanish (Ecuador)': "es-EC";
+  'Spanish (El Salvador)': "es-SV";
+  'Spanish (Espa\u00F1a)': "es-ES";
+  'Spanish (Guatemala)': "es-GT";
+  'Spanish (Honduras)': "es-HN";
+  'Spanish (Mexico)': "es-MX";
+  'Spanish (Nicaragua)': "es-NI";
+  'Spanish (Panama)': "es-PA";
+  'Spanish (Paraguay)': "es-PY";
+  'Spanish (Peru)': "es-PE";
+  'Spanish (Puerto Rico)': "es-PR";
+  'Spanish (United States)': "es-US";
+  'Spanish (Uruguay)': "es-UY";
+  'Spanish (Venezuela)': "es-VE";
+  Sundanese: "su";
+  Sutu: "sx";
+  Swahili: "sw";
+  Swedish: "sv";
+  'Swedish (Finland)': "sv-FI";
+  'Swedish (Sweden)': "sv-SE";
+  'Swiss German': "gsw";
+  'Swiss German (Liechtenstein)': "gsw-LI";
+  'Swiss German (Switzerland)': "gsw-CH";
+  Syriac: "syr";
+  Tagalog: "tl";
+  Tahitian: "ty";
+  Tajik: "tg";
+  Tamil: "ta";
+  Tatar: "tt";
+  Telugu: "te";
+  Thai: "th";
+  Tibetan: "bo";
+  Tigrinya: "ti";
+  Tonga: "to";
+  Tsonga: "ts";
+  Tswana: "tn";
+  Turkish: "tr";
+  Turkmen: "tk";
+  Twi: "tw";
+  Uighur: "ug";
+  Ukrainian: "uk";
+  Urdu: "ur";
+  Uzbek: "uz";
+  Venda: "ve";
+  Vietnamese: "vi";
+  Volapuk: "vo";
+  Walloon: "wa";
+  Welsh: "cy";
+  Wolof: "wo";
+  Xhosa: "xh";
+  Yiddish: "yi";
+  Yoruba: "yo";
+  Zhuang: "za";
+  Zulu: "zu";
+};
+/** Overrides type */
+type BrowserLanguage = (typeof BrowserLanguage)[keyof typeof BrowserLanguage];
+//#endregion
+//#region src/enums/experience.d.ts
+/**
+ * Describes whether listed countries/country subdivisions are included in an experience
+ */
+declare const RegionsOperator: {
+  /** The listed countries/country subdivisions, time zones, and languages are included in this experience */In: "IN"; /** The listed countries/country subdivisions, time zones, and languages are NOT included in this experience */
+  NotIn: "NOT_IN";
+};
+/** Override type */
+type RegionsOperator = (typeof RegionsOperator)[keyof typeof RegionsOperator];
+//#endregion
+//#region src/enums/consentExpiry.d.ts
+/**
+ * Enum of options available for behavior to exhibit when the user's consent has expired
+ */
+declare const OnConsentExpiry: {
+  /** Reprompts the user to change or confirm their selection */Prompt: "Prompt"; /** Resets the user's consent and reprompts them */
+  ResetAll: "ResetAll"; /** Resets the user's opted-in purposes and reprompts them */
+  ResetOptIns: "ResetOptIns";
+};
+/** Override type */
+type OnConsentExpiry = (typeof OnConsentExpiry)[keyof typeof OnConsentExpiry];
+//#endregion
+//#region src/ui.d.ts
+/** Transcend Smart Quarantine API (window.transcend) */
+type PreInitTranscendAPI = {
+  /** Ready event subscriber */ready(callback: (transcend: TranscendAPI) => void): void; /** Ready event dispatch queue */
+  readyQueue: ((transcend: TranscendAPI) => void)[];
+};
+/** showConsentManager() */
+interface ShowConsentManagerOptions {
+  /** View state */
+  viewState?: ViewState;
+}
+/**
+ * Input for fetching a policy from Transcend and inserting template variables
+ */
+type GetTranscendPolicies = {
+  /** The language to fetch policy for - defaults to currently selected language key */locale?: LocaleValue; /** Template variables to dynamically inject into the policy */
+  variables?: ObjByString;
+  /**
+   * The UUID of the policies defined in Transcend to fetch
+   *
+   * This can be pulled from the URL
+   * @see https://app.transcend.io/privacy-center/policies
+   */
+  policyIds?: string[];
+  /**
+   * The titles of the policies defined in Transcend to fetch
+   *
+   * This can be pulled from the URL
+   * @see https://app.transcend.io/privacy-center/policies
+   */
+  policyTitles?: string[];
+};
+/**
+ * The returning Transcend policy
+ */
+type TranscendPolicy = {
+  /** The policy UUID */id: string; /** The policy title */
+  title: string; /** The policy content */
+  content: string;
+};
+/**
+ * Transcend Consent Manager external methods
+ */
+type ConsentManagerAPI = Readonly<{
+  /** Possible ViewState values */viewStates: Set<ViewState>; /** Expose an option to grab the current view state */
+  getViewState: () => ViewState; /** Get the current active language */
+  getPolicies: (input?: GetTranscendPolicies) => Promise<TranscendPolicy[]>; /** Callback that sets any dynamic variables that should be exposed to the consent UI messages */
+  setUiVariables: (variables: ObjByString) => Promise<void>; /** Get the current value of Transcend UI variables */
+  getUiVariables: () => ObjByString; /** Set consent change authorization key */
+  setAuth?: (key: AirgapAuthMap['key']) => void; /** Change the current privacy policy URL */
+  setPrivacyPolicy: (privacyPolicyLink: string) => void; /** Change the current secondary policy URL */
+  setSecondaryPolicy: (privacyPolicyLink: string) => void; /** Show consent manager unless recently dismissed */
+  autoShowConsentManager(options?: ShowConsentManagerOptions): Promise<void>; /** Show consent manager */
+  showConsentManager(options?: ShowConsentManagerOptions): Promise<void>; /** Set the current active language */
+  setActiveLocale(locale: ConsentManagerSupportedTranslationValue): Promise<void>; /** Get the currently active locale */
+  getActiveLocale: () => ConsentManagerSupportedTranslationValue; /** Toggle consent manager */
+  toggleConsentManager(options?: ShowConsentManagerOptions): Promise<void>; /** Hide consent manager */
+  hideConsentManager(): Promise<void>; /** Opt out of the sale of personal info & show a disclosure */
+  doNotSell(auth: AirgapAuth, options?: ShowConsentManagerOptions): Promise<void>; /** Opt out of all purposes */
+  optOutNotice(auth: AirgapAuth, options?: ShowConsentManagerOptions): Promise<void>; /** Sets local tcf string (does not sync to xdi or preference store) */
+  setTCFConsent?: (auth: AirgapAuth, tcString: string) => Promise<void>; /** UI version */
+  version?: string;
+}> & EventTarget;
+/**
+ * `transcend` event types
+ */
+type TranscendEventType = 'view-state-change';
+/** 'view-state-change' custom event details */
+type ViewStateEventDetails = {
+  /** The new, now-current view state */viewState: ViewState; /** The previous view state */
+  previousViewState: ViewState | null;
+};
+/** Transcend Smart Quarantine API (window.transcend) */
+type TranscendAPI = PreInitTranscendAPI & ConsentManagerAPI;
+/**
+ * Customer theming
+ */
+declare const ConsentManagerTheme: t.TypeC<{
+  /** Primary color */primaryColor: t.StringC; /** Font color */
+  fontColor: t.StringC;
+}>;
+/** Type override */
+type ConsentManagerTheme = t.TypeOf<typeof ConsentManagerTheme>;
+/**
+ * Mobile-first responsive breakpoints
+ * No media query for mobile, which is the default
+ */
+declare const ConsentManagerBreakpoints: t.TypeC<{
+  /** In px, at or above this width is tablet */tablet: t.StringC; /** In px, at or above this width is desktop */
+  desktop: t.StringC;
+}>;
+/** Type override */
+type ConsentManagerBreakpoints = t.TypeOf<typeof ConsentManagerBreakpoints>;
+/**
+ * TODO: https://transcend.height.app/T-19149 - remove
+ * @deprecated
+ */
+declare const PrivacyRegimeToInitialViewStateInput: t.PartialC<{
+  Unknown: 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;
+  }>;
+  CPRA: 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;
+  }>;
+  GDPR: 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;
+  }>;
+  LGPD: 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;
+  }>;
+  CDPA: 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;
+  }>;
+  CPA: 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;
+  }>;
+  NEVADA_SB220: 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;
+  }>;
+  nFADP: 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;
+  }>;
+  US_DNSS: 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;
+  }>;
+}>;
+/**
+ * TODO: https://transcend.height.app/T-19149 - remove
+ * @deprecated
+ */
+type PrivacyRegimeToInitialViewStateInput = t.TypeOf<typeof PrivacyRegimeToInitialViewStateInput>;
+/**
+ * TODO: https://transcend.height.app/T-19149 - remove
+ * @deprecated
+ */
+declare const PrivacyRegimeToInitialViewState: t.RecordC<t.KeyofC<{
+  Unknown: unknown;
+  CPRA: unknown;
+  GDPR: unknown;
+  LGPD: unknown;
+  CDPA: unknown;
+  CPA: unknown;
+  NEVADA_SB220: unknown;
+  nFADP: unknown;
+  US_DNSS: unknown;
+}>, 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;
+}>>;
+/**
+ * TODO: https://transcend.height.app/T-19149 - remove
+ * @deprecated
+ */
+type PrivacyRegimeToInitialViewState = t.TypeOf<typeof PrivacyRegimeToInitialViewState>;
+declare const ExperienceToInitialViewState: t.RecordC<t.StringC, 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;
+}>>;
+/** type overload */
+type ExperienceToInitialViewState = t.TypeOf<typeof ExperienceToInitialViewState>;
+declare const RequiredConsentManagerConfig: t.TypeC<{
+  /** Customer theming */theme: t.TypeC<{
+    /** Primary color */primaryColor: t.StringC; /** Font color */
+    fontColor: t.StringC;
+  }>; /** A set of responsive breakpoints */
+  breakpoints: t.TypeC<{
+    /** In px, at or above this width is tablet */tablet: t.StringC; /** In px, at or above this width is desktop */
+    desktop: t.StringC;
+  }>; /** The privacy policy URL to redirect to */
+  privacyPolicy: t.StringC; /** The secondary policy URL to redirect to */
+  secondaryPolicy: t.StringC; /** Custom CSS stylesheet */
+  css: t.StringC; /** Path to localizations directory */
+  messages: t.StringC; /** What state the consent manager should launch in */
+  initialViewStateByPrivacyRegime: t.RecordC<t.StringC, 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;
+  }>>; /** What state the consent manager should go to when dismissed */
+  dismissedViewState: t.KeyofC<{
+    Collapsed: unknown;
+    Closed: unknown;
+  }>;
+}>;
+/** type overload */
+type RequiredConsentManagerConfig = t.TypeOf<typeof RequiredConsentManagerConfig>;
+declare const OptionalConsentManagerConfig: t.PartialC<{
+  /** The set of enabled languages - CSV of ConsentManagerSupportedTranslationValue */languages: t.StringC; /** The override value for the consent banner z-index */
+  uiZIndex: t.StringC;
+  /**
+   * The override value for the consent banner shadow root state
+   *
+   * Potential values: 'closed' (default) and 'open'
+   */
+  uiShadowRoot: t.StringC;
+  /**
+   * The override value for whether to focus on the first descendant of the root arg w/data-initialFocus attribute
+   * Potential values: `'on'` (default) or `'off'`
+   *
+   */
+  autofocus: t.KeyofC<{
+    on: null;
+    off: null;
+  }>;
+}>;
+/** type overload */
+type OptionalConsentManagerConfig = t.TypeOf<typeof OptionalConsentManagerConfig>;
+/** Consent manager UI configuration */
+declare const ConsentManagerConfig: t.IntersectionC<[t.TypeC<{
+  /** Customer theming */theme: t.TypeC<{
+    /** Primary color */primaryColor: t.StringC; /** Font color */
+    fontColor: t.StringC;
+  }>; /** A set of responsive breakpoints */
+  breakpoints: t.TypeC<{
+    /** In px, at or above this width is tablet */tablet: t.StringC; /** In px, at or above this width is desktop */
+    desktop: t.StringC;
+  }>; /** The privacy policy URL to redirect to */
+  privacyPolicy: t.StringC; /** The secondary policy URL to redirect to */
+  secondaryPolicy: t.StringC; /** Custom CSS stylesheet */
+  css: t.StringC; /** Path to localizations directory */
+  messages: t.StringC; /** What state the consent manager should launch in */
+  initialViewStateByPrivacyRegime: t.RecordC<t.StringC, 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;
+  }>>; /** What state the consent manager should go to when dismissed */
+  dismissedViewState: t.KeyofC<{
+    Collapsed: unknown;
+    Closed: unknown;
+  }>;
+}>, t.PartialC<{
+  /** The set of enabled languages - CSV of ConsentManagerSupportedTranslationValue */languages: t.StringC; /** The override value for the consent banner z-index */
+  uiZIndex: t.StringC;
+  /**
+   * The override value for the consent banner shadow root state
+   *
+   * Potential values: 'closed' (default) and 'open'
+   */
+  uiShadowRoot: t.StringC;
+  /**
+   * The override value for whether to focus on the first descendant of the root arg w/data-initialFocus attribute
+   * Potential values: `'on'` (default) or `'off'`
+   *
+   */
+  autofocus: t.KeyofC<{
+    on: null;
+    off: null;
+  }>;
+}>]>;
+/** Type override */
+type ConsentManagerConfig = t.TypeOf<typeof ConsentManagerConfig>;
+/** Input for Consent manager UI configuration */
+declare const ConsentManagerConfigInput: t.PartialC<{
+  /** Customer theming */theme: t.TypeC<{
+    /** Primary color */primaryColor: t.StringC; /** Font color */
+    fontColor: t.StringC;
+  }>; /** A set of responsive breakpoints */
+  breakpoints: t.TypeC<{
+    /** In px, at or above this width is tablet */tablet: t.StringC; /** In px, at or above this width is desktop */
+    desktop: t.StringC;
+  }>; /** The privacy policy URL to redirect to */
+  privacyPolicy: t.StringC; /** The secondary policy URL to redirect to */
+  secondaryPolicy: t.StringC; /** Custom CSS stylesheet */
+  css: t.StringC; /** Path to localizations directory */
+  messages: t.StringC; /** What state the consent manager should launch in */
+  initialViewStateByPrivacyRegime: t.RecordC<t.StringC, 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;
+  }>>; /** What state the consent manager should go to when dismissed */
+  dismissedViewState: t.KeyofC<{
+    Collapsed: unknown;
+    Closed: unknown;
+  }>; /** The set of enabled languages - CSV of ConsentManagerSupportedTranslationValue */
+  languages: t.StringC; /** The override value for the consent banner z-index */
+  uiZIndex: t.StringC;
+  /**
+   * The override value for the consent banner shadow root state
+   *
+   * Potential values: 'closed' (default) and 'open'
+   */
+  uiShadowRoot: t.StringC;
+  /**
+   * The override value for whether to focus on the first descendant of the root arg w/data-initialFocus attribute
+   * Potential values: `'on'` (default) or `'off'`
+   *
+   */
+  autofocus: t.KeyofC<{
+    on: null;
+    off: null;
+  }>;
+}>;
+/** Type override */
+type ConsentManagerConfigInput = t.TypeOf<typeof ConsentManagerConfigInput>;
+declare const TCFConfig: t.TypeC<{
+  /** Path to vendor-list.json */vendorList: t.StringC; /** Custom CSS stylesheet */
+  css: t.StringC; /** Path to localizations directory */
+  messages: t.StringC;
+}>;
+/** Type override */
+type TCFConfig = t.TypeOf<typeof TCFConfig>;
+/** Configuration that are passed directly to the TCF module, not via airgap.j */
+declare const TCFBundledDataConfig: t.PartialC<{
+  /** Mapping of TCF Purpose ID to airgap tracking types */purposeMap: t.ArrayC<t.TupleC<[t.NumberC, t.ArrayC<t.StringC>]>>; /** These TCF purposes cannot be processed on the basis of legitimate interests */
+  restrictLegitimateInterestPurposes: t.ArrayC<t.NumberC>; /** Vendors that Transcend Consent regulates because they haven't registered with IAB TCF */
+  nonTcfVendors: t.ArrayC<t.IntersectionC<[t.TypeC<{
+    name: t.StringC;
+    purposes: t.ArrayC<t.StringC>;
+  }>, t.PartialC<{
+    description: t.StringC;
+    privacyPolicyUrl: t.StringC;
+  }>]>>; /** Comma separated list of languages to support in the UI */
+  languages: t.StringC; /** Default locale to use for the UI internationalization  */
+  locale: t.StringC;
+  /**
+   * Whether or not to enable integration between Google Consent Mode and TCF.
+   * More docs here https://developers.google.com/tag-platform/security/guides/implement-TCF-strings#cmp-api
+   */
+  enableAdvertiserConsentMode: t.BooleanC;
+}>;
+/** Type override */
+type TCFBundledDataConfig = t.TypeOf<typeof TCFBundledDataConfig>;
+/** Input for Consent manager UI configuration */
+declare const TCFConfigInput: t.PartialC<{
+  /** Path to vendor-list.json */vendorList: t.StringC; /** Custom CSS stylesheet */
+  css: t.StringC; /** Path to localizations directory */
+  messages: t.StringC;
+}>;
+/** Type override */
+type TCFConfigInput = t.TypeOf<typeof TCFConfigInput>;
+/**
+ * Properties exposed on `self` by the Transcend Smart Quarantine
+ */
+type TranscendView = Window & {
+  /** Transcend Smart Quarantine API */transcend: TranscendAPI;
+};
+declare const DEFAULT_VIEW_STATE_BY_PRIVACY_REGIME: ExperienceToInitialViewState;
+//#endregion
+//#region src/constants.d.ts
+declare const UNKNOWN_DEFAULT_EXPERIENCE = "Unknown";
+declare const GDPR_PURPOSES: [PrivacyRegime[], TrackingPurpose[]];
+declare const DEFAULT_REGIME_TRACKING_PURPOSE_SCOPES: RegimePurposeScopesConfig;
+declare const DEFAULT_REGIME_PURPOSE_OPT_OUTS: RegimePurposeScopesConfig;
+declare const DEFAULT_EXPERIENCE_PURPOSE_OPT_OUTS: any;
+declare const DEFAULT_EXPERIENCE_PURPOSE_SCOPES: any;
+declare const REGIME_TIMEZONES: Record<PrivacyRegime, string[]>;
+declare const REGIME_DISPLAY_PRIORITY: Record<PrivacyRegime, number>;
+/**
+ * These TCF Purposes cannot be allowed to process under legitimate interest legal basis
+ * Source:
+ * https://iabeurope.eu/iab-europe-transparency-consent-framework-policies/#:~:text=Appendix%20A:%20Definitions%20Of%20Purposes,%20Features%20And%20Categories%20Of%20Data
+ */
+declare const DEFAULT_RESTRICT_LEGIT_INTEREST_PROCESSING: number[];
+//#endregion
+//#region src/experience.d.ts
+interface Region {
+  /** A country's ISO code */
+  country: IsoCountryCode;
+  /** A country subdivision ISO code */
+  countrySubDivision?: string;
+}
+interface ExperiencePurposeInput {
+  /** name of the purpose */
+  purpose: Purpose;
+  /** opt out by default */
+  defaultOptOut: boolean;
+}
+interface ExperienceInput {
+  /** The regime determining the default experience */
+  name: PrivacyRegime;
+  /** The display name of the experience */
+  displayName: string;
+  /** A list of regions to be included/not included in this experience */
+  regions: Region[];
+  /** A list of browser languages that this experience applies to */
+  browserLanguages: string[];
+  /** A list of browser time zones that this experience applies to */
+  browserTimeZones: string[];
+  /** Whether the listed regions are included or excluded from the experience */
+  operator: RegionsOperator;
+  /** If data subject linked to multiple experiences, display priority for experiences. Lower number, higher priority. */
+  displayPriority: number;
+  /** The view state to display on transcend.showConsentManager() */
+  viewState: InitialViewState;
+  /** experience purposes to be added */
+  experiencePurposeInputs: ExperiencePurposeInput[];
+  /** Time in months after which a user's opt-in consent should expire */
+  consentExpiry: number;
+  /** Behavior to exhibit when the user's consent has expired */
+  onConsentExpiry: OnConsentExpiry;
+}
+declare const REGIME_REGIONS: Record<PrivacyRegime, Region[]>;
+declare const REGIME_LANGUAGES: Record<PrivacyRegime, string[]>;
+declare const REGIME_CONSENT_EXPIRY: Record<PrivacyRegime, number>;
+declare const REGIME_ON_CONSENT_EXPIRY: Record<PrivacyRegime, OnConsentExpiry>;
+/**
+ * construct default experience for regime
+ * @param regime - regime
+ * @returns ExperienceInput
+ */
+declare function defaultExperience(regime: PrivacyRegime): ExperienceInput;
+declare const DEFAULT_EXPERIENCES: {
+  Unknown: ExperienceInput;
+  CPRA: ExperienceInput;
+  GDPR: ExperienceInput;
+  LGPD: ExperienceInput;
+  CDPA: ExperienceInput;
+  CPA: ExperienceInput;
+  NEVADA_SB220: ExperienceInput;
+  nFADP: ExperienceInput;
+  US_DNSS: ExperienceInput;
+};
+//#endregion
+//#region src/mobile.d.ts
+declare const ConsentSDK: t.TypeC<{
+  /** Unique identifier for the SDK */id: t.StringC; /** airgap purposes applicable to this SDK */
+  purposes: t.ArrayC<t.StringC>;
+}>;
+/**
+ * Type override
+ */
+type ConsentSDK = t.TypeOf<typeof ConsentSDK>;
+declare const ConsentService: t.IntersectionC<[t.TypeC<{
+  name: t.StringC;
+}>, t.PartialC<{
+  sdks: t.ArrayC<t.TypeC<{
+    /** Unique identifier for the SDK */id: t.StringC; /** airgap purposes applicable to this SDK */
+    purposes: t.ArrayC<t.StringC>;
+  }>>;
+  tcfId: t.NumberC;
+}>]>;
+/**
+ * Type override
+ */
+type ConsentService = t.TypeOf<typeof ConsentService>;
+declare const MobileConfig: t.TypeC<{
+  services: t.ArrayC<t.IntersectionC<[t.TypeC<{
+    name: t.StringC;
+  }>, t.PartialC<{
+    sdks: t.ArrayC<t.TypeC<{
+      /** Unique identifier for the SDK */id: t.StringC; /** airgap purposes applicable to this SDK */
+      purposes: t.ArrayC<t.StringC>;
+    }>>;
+    tcfId: t.NumberC;
+  }>]>>;
+}>;
+/**
+ * Type override
+ */
+type MobileConfig = t.TypeOf<typeof MobileConfig>;
+//#endregion
+export { AirgapAPI, AirgapAuth, AirgapAuthMap, AirgapConsentEventType, AirgapDOMRequestSource, AirgapEventType, AirgapExportOptions, AirgapQueues, AirgapRequestSource, AirgapSyncType, AirgapSystemStatus, AirgapToggleOptions, AirgapWatcher, AutoOptOut, AutoOptOutForDNT, AutoOptOutForGDPR, AutoOptOutForGPC, BooleanString, BrowserLanguage, ConfigurablePurpose, ConsentChange, ConsentChangeEventDetails, ConsentChangeEventPayload, ConsentManagerAPI, ConsentManagerBreakpoints, ConsentManagerConfig, ConsentManagerConfigInput, ConsentManagerTheme, ConsentOptions, ConsentPreferencesBody, ConsentSDK, ConsentService, ConsentTokenPayload, ConsoleSafeLogLevel, Cookie, CookieOverride, CookieWatcher, CoreTrackingConsentDetails, DEFAULT_EXPERIENCES, DEFAULT_EXPERIENCE_PURPOSE_OPT_OUTS, DEFAULT_EXPERIENCE_PURPOSE_SCOPES, DEFAULT_REGIME_PURPOSE_OPT_OUTS, DEFAULT_REGIME_TRACKING_PURPOSE_SCOPES, DEFAULT_RESTRICT_LEGIT_INTEREST_PROCESSING, DEFAULT_VIEW_STATE_BY_PRIVACY_REGIME, DeepViewState, DefaultConsentConfig, DefaultConsentConfigValue, DefaultConsentValue, DismissedViewState, ExperienceInput, ExperiencePurposeInput, ExperienceToInitialViewState, FullTrackingConsentDetails, FullTrackingConsentDetailsWithNulls, GDPR_PURPOSES, GetPurposeTypesOptions, GetTranscendPolicies, IABViewState, IDynamicNodeReference, IPendingCookieMutation, IPendingEvent, IPendingMutation, IPendingRequest, InitialTranscendViewState, InitialViewState, InstantiatedPendingCookieMutationProps, InstantiatedPendingRequestProps, KnownDefaultPurpose, LogEmitter, LogEntry, LogEntryType, LogItem, LogLevel, LogMessage, LogTag, Logger, Metadata, MobileConfig, NonTcfVendor, OnConsentExpiry, OptionalConsentManagerConfig, PendingCookieMutationDescriptor, PendingCookieMutationInit, PendingCookieMutationJSON, PendingCookieQueue, PendingEventDescriptor, PendingEventInit, PendingEventQueue, PendingMutationDescriptor, PendingMutationInit, PendingMutationJSON, PendingMutationQueue, PendingRequestDescriptor, PendingRequestInit, PendingRequestJSON, PendingRequestQueue, PreInitTranscendAPI, PrivacyRegime, PrivacyRegimeEnum, PrivacyRegimeToInitialViewState, PrivacyRegimeToInitialViewStateInput, Purpose, REGIME_CONSENT_EXPIRY, REGIME_DISPLAY_PRIORITY, REGIME_LANGUAGES, REGIME_ON_CONSENT_EXPIRY, REGIME_REGIONS, REGIME_TIMEZONES, RegimePurposeScopesConfig, RegimeToPurposeScopes, Region, RegionsOperator, Removable, RequestOverride, RequiredConsentManagerConfig, ReservedMetadata, ResponseViewState, ShowConsentManagerOptions, SpecialTrackingPurpose, Stringifiable, SyncOptions, TCFBundledDataConfig, TCFConfig, TCFConfigInput, TcfGvlV3DataCategory, TcfGvlV3DataRetention, TcfGvlV3Purpose, TcfGvlV3Url, TcfGvlV3Vendor, TcfPurpose, TcfStack, TcfV2VendorList, TcfV3VendorList, TcfVendor, TcfVendorListVersion, TrackingConsent, TrackingConsentDetails, TrackingConsentOptionalData, TrackingConsentWithNulls, TrackingEventType, TrackingPurpose, TrackingPurposeDetails, TrackingPurposes, TrackingPurposesConfig, TrackingPurposesTypes, TranscendAPI, TranscendEventType, TranscendPolicy, TranscendView, UNKNOWN_DEFAULT_EXPERIENCE, UserPrivacySignal, UserPrivacySignalEnum, ViewState, ViewStateEventDetails, defaultExperience };
+//# sourceMappingURL=index.d.mts.map