@transcend-io/airgap.js-types 10.7.9 → 10.8.0

package/build-esm/core.d.ts

@@ -0,0 +1,688 @@
+import * as t from 'io-ts';
+/** Transcend logger items */
+export declare type LogItem = {
+    /** Log item content */
+    content: any;
+    /** Log item styles */
+    styles: string[];
+};
+/** Transcend logger entry tag */
+export declare 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 */
+export declare type LogMessage = LogItem;
+/** Console-safe log levels */
+export 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 */
+export declare type ConsoleSafeLogLevel = t.TypeOf<typeof ConsoleSafeLogLevel>;
+/** Airgap log levels */
+export 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 */
+export declare type LogLevel = t.TypeOf<typeof LogLevel>;
+/** Airgap logger entry types */
+export declare type LogEntryType = LogLevel;
+/** Airgap logger entries */
+export declare type LogEntry = {
+    /** Log entry tag */
+    tag: LogTag;
+    /** Log entry message */
+    message: LogMessage;
+};
+/**
+ * Log emitter function
+ */
+export declare type LogEmitter = {
+    /** Styled log emitter function */
+    styled(styles?: null | string | string[], ...entries: any[]): void;
+} & ((...entries: any[]) => void);
+/** Transcend Logger API */
+export declare 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 */
+export declare 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?: UIEvent;
+    /** Automatically reload the page if needed to remove CSP. `false` by default. */
+    autoReload?: boolean;
+};
+/** Airgap authorization proof */
+export declare type AirgapAuth = null | AirgapAuthMap
+/** A user-initiated interaction event that was just dispatched. */
+ | UIEvent
+/** 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'` */
+export declare const BooleanString: t.KeyofC<{
+    on: null;
+    off: null;
+}>;
+/** Type override */
+export declare type BooleanString = t.TypeOf<typeof BooleanString>;
+/** Data privacy legal regimes */
+export declare type PrivacyRegime = string;
+export interface GetPurposeTypesOptions {
+    /** Regimes to include */
+    regimes?: PrivacyRegime[];
+    /** Privacy signals to include */
+    signals?: UserPrivacySignal[];
+}
+/**
+ * Regime to purpose scope map
+ */
+export declare type RegimeToPurposeScopes = [PrivacyRegime[], TrackingPurpose[]][];
+/** Reserved metadata, currently used for airgap module data syncing */
+export interface ReservedMetadata {
+    /** Top-level key to avoid polluting the metadata key space */
+    tcmp?: Record<string, unknown>;
+}
+/**
+ * Extra metadata to be synced along with consent
+ */
+export declare type Metadata = Record<string, unknown>;
+/** setConsent() options */
+export interface ConsentOptions {
+    /** Was consent confirmed by the user? */
+    confirmed?: boolean;
+    /** Was the UI shown to the user? */
+    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.js API */
+export declare type AirgapAPI = Readonly<{
+    /** 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(): Promise<void>;
+    /** Resolve airgap request overrides for a URL */
+    resolve(url: Stringifiable): Stringifiable;
+    /** 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 */
+    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;
+    /** 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;
+    /** 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>;
+    /** 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 event types that send the ConsentChangeEventDetails object with them
+ */
+export declare type AirgapConsentEventType = 'consent-change' | 'sync' | 'consent-resolution';
+/**
+ * airgap.js event type
+ */
+export declare type AirgapEventType = AirgapConsentEventType | 'purpose-map-load';
+export interface ConsentChangeEventPayload {
+    /** consent change event details */
+    detail: ConsentChangeEventDetails;
+}
+/** 'consent-change' custom event details */
+export declare 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) */
+export declare type Removable = {
+    /** Remove/revoke process */
+    remove(): void;
+};
+/** Any value which implements `toString()` */
+export declare type Stringifiable = string | (string & {
+    toString(): string;
+});
+/** Special `defaultConsent` automatic opt-out value for any potential reason */
+export declare const AutoOptOut: t.LiteralC<"Auto">;
+/** Type override */
+export declare type AutoOptOut = t.TypeOf<typeof AutoOptOut>;
+/** Special `defaultConsent` automatic opt-out value for GDPR-protected users */
+export declare const AutoOptOutForGDPR: t.LiteralC<"AutoGDPR">;
+/** Type override */
+export declare 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.
+ */
+export declare const AutoOptOutForDNT: t.LiteralC<"AutoDNT">;
+/** Type override */
+export declare type AutoOptOutForDNT = t.TypeOf<typeof AutoOptOutForDNT>;
+/**
+ * Special `defaultConsent` automatic opt-out value for users with GPC enabled.
+ */
+export declare const AutoOptOutForGPC: t.LiteralC<"AutoGPC">;
+/** Type override */
+export declare type AutoOptOutForGPC = t.TypeOf<typeof AutoOptOutForGPC>;
+/** Potential values for `defaultConsent` config token list */
+export 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 */
+export declare type DefaultConsentConfigValue = t.TypeOf<typeof DefaultConsentConfigValue>;
+/** User-configurable user agent privacy signal */
+export declare const UserPrivacySignal: t.UnionC<[t.LiteralC<"GPC">, t.LiteralC<"DNT">]>;
+/** type overload */
+export declare type UserPrivacySignal = t.TypeOf<typeof UserPrivacySignal>;
+/** Tracking purpose metadata */
+export 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 */
+export declare type TrackingPurposeDetails = t.TypeOf<typeof TrackingPurposeDetails>;
+/** Tracking purposes types configuration */
+export 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 */
+export declare type TrackingPurposesTypes = t.TypeOf<typeof TrackingPurposesTypes>;
+/** Fully-resolved `defaultConsent` config */
+export 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 */
+export declare type DefaultConsentConfig = t.TypeOf<typeof DefaultConsentConfig>;
+/** Tracking purposes configuration */
+export 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 */
+export declare 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;
+};
+export declare const TrackingConsent: t.IntersectionC<[t.PartialC<{
+    Essential: t.LiteralC<true>;
+    Unknown: t.LiteralC<false>;
+}>, t.RecordC<t.StringC, t.UnionC<[t.BooleanC, t.UndefinedC]>>]>;
+/**
+ * Type override
+ */
+export declare type TrackingConsent = t.TypeOf<typeof TrackingConsent>;
+export declare const TrackingConsentWithNulls: t.RecordC<t.StringC, t.UnionC<[t.BooleanC, t.UndefinedC, t.NullC]>>;
+/** Type override */
+export declare type TrackingConsentWithNulls = t.TypeOf<typeof TrackingConsent>;
+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) */
+    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 */
+export declare type CoreTrackingConsentDetails = t.TypeOf<typeof CoreTrackingConsentDetails>;
+export 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) */
+    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.UndefinedC]>>]>;
+}>]>;
+/** Override types. */
+export declare type TrackingConsentDetails = t.TypeOf<typeof TrackingConsentDetails>;
+export 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<{
+        TCF_EU: unknown;
+        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;
+        CompleteOptions: unknown;
+        CompleteOptionsInverted: unknown;
+        Hidden: unknown;
+        DoNotSellDisclosure: unknown;
+        OptOutDisclosure: unknown;
+        LanguageOptions: unknown;
+        Collapsed: unknown;
+        Closed: unknown;
+    }>;
+    /** Airgap Version */
+    airgapVersion: t.StringC;
+}>;
+export 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) */
+    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.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<{
+        TCF_EU: unknown;
+        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;
+        CompleteOptions: unknown;
+        CompleteOptionsInverted: unknown;
+        Hidden: unknown;
+        DoNotSellDisclosure: unknown;
+        OptOutDisclosure: unknown;
+        LanguageOptions: unknown;
+        Collapsed: unknown;
+        Closed: unknown;
+    }>;
+    /** Airgap Version */
+    airgapVersion: t.StringC;
+}>]>;
+/** Override types. */
+export declare type FullTrackingConsentDetails = t.TypeOf<typeof FullTrackingConsentDetails>;
+export 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) */
+    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<{
+        TCF_EU: unknown;
+        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;
+        CompleteOptions: unknown;
+        CompleteOptionsInverted: unknown;
+        Hidden: 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. */
+export declare type FullTrackingConsentDetailsWithNulls = t.TypeOf<typeof FullTrackingConsentDetailsWithNulls>;
+export 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) */
+        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.UndefinedC]>>]>;
+    }>]>;
+}>;
+/** Override types. */
+export declare type ConsentPreferencesBody = t.TypeOf<typeof ConsentPreferencesBody>;
+export declare const ConsentTokenPayload: t.IntersectionC<[t.TypeC<{
+    encryptedIdentifier: t.StringC;
+}>, t.PartialC<{
+    deprecatedEncryptedIdentifiers: t.ArrayC<t.StringC>;
+}>]>;
+/** Type override */
+export declare type ConsentTokenPayload = t.TypeOf<typeof ConsentTokenPayload>;
+/** Tracking purpose */
+export declare const TrackingPurpose: t.UnionC<[t.KeyofC<{
+    Unknown: "Unknown";
+    Essential: "Essential";
+}>, t.StringC]>;
+/** Type override */
+export declare type TrackingPurpose = t.TypeOf<typeof TrackingPurpose>;
+/** Tracking purposes */
+export declare type TrackingPurposes = Set<TrackingPurpose>;
+/** Tracking consent change diffs */
+export declare const ConsentChange: t.RecordC<t.UnionC<[t.KeyofC<{
+    Unknown: "Unknown";
+    Essential: "Essential";
+}>, t.StringC]>, t.BooleanC>;
+/** type overload */
+export declare type ConsentChange = t.TypeOf<typeof ConsentChange>;
+/** Regime purpose scopes configuration */
+export declare const RegimePurposeScopesConfig: t.ArrayC<t.BrandC<t.ArrayC<t.ArrayC<t.StringC>>, import("@transcend-io/type-utils").FixedLengthArrayBrand<t.ArrayC<t.StringC>>>>;
+/** Type override */
+export declare type RegimePurposeScopesConfig = [
+    /** Regimes */
+    regimes: string[],
+    /** In-scope purposes */
+    purposes: TrackingPurpose[]
+][];
+export {};
+//# sourceMappingURL=core.d.ts.map