import { InAppMessageAfterConditionDto, InAppMessageAlignmentDto, InAppMessageContextActionDto, InAppMessageContextButtonDto, InAppMessageContextCloseButtonDto, InAppMessageContextDto, InAppMessageContextImageAutoScrollDto, InAppMessageContextImageDto, InAppMessageContextMessageDto, InAppMessageContextTextContentDto, InAppMessageContextTextDto, InAppMessageDelayDto, InAppMessageDto, InAppMessageDurationCapDto, InAppMessageEvaluateContextDto, InAppMessageEventFrequencyCapDto, InAppMessageEventTriggerRuleDto, InAppMessageHtmlDto, InAppMessageIdentifierCapDto, InAppMessageLayoutDto, InAppMessagePositionalButtonDto, InAppMessageTargetContextDto, InAppMessageTargetRuleOverrideDto, InAppMessageTimetableDto, InAppMessageTimetableSlotDto } from "../workspace/iam";
import { BucketDto, ContainerDto, ContainerGroupDto, EventTypeDto, ExecutionTargetUrlsDto, ExperimentDto, ParameterConfigurationDto, RemoteConfigParameterDto, RemoteConfigParameterValueDto, RemoteConfigTargetRuleDto, SegmentDto, SplitUrlConfigDto, TargetActionDto, TargetConditionDto, TargetDto, TargetKeyDto, TargetMatchDto, TargetRuleDto } from "../workspace/dto";
import { PropertyOperation } from "../../../hackle/property/PropertyOperation";
import { DayOfWeek } from "../util/TimeUtil";
import { ParameterConfig } from "../config/ParameterConfig";
import { HackleExperiment, HackleVariation } from "../../../public/model";
import { UserTargetEventDto, UserTargetEventPropertyDto, UserTargetStatDto } from "../user/dto";
export declare type Int = number;
export declare type Long = number;
export declare type List<T> = T[];
export declare type Double = number;
export declare type UserId = string;
export declare type VariationId = Long;
export declare type VariationKey = string;
export declare type ExperimentId = Long;
export declare type ExperimentKey = Long;
export declare type BucketId = Long;
export declare type EventId = Long;
export declare type EventKey = string;
export declare type SegmentKey = string;
export declare type ContainerId = Long;
export declare type ParameterConfigurationId = Long;
export declare type RemoteConfigParameterKey = string;
export declare type InAppMessageKey = Long;
/**
 * An object that contains the decided config parameter value and the reason for the config parameter decision.
 */
export declare class RemoteConfigDecision {
    value: string | number | boolean;
    reason: DecisionReason;
    constructor(value: string | number | boolean, reason: DecisionReason);
    static of(value: string | number | boolean, reason: DecisionReason): RemoteConfigDecision;
}
/**
 * An object that contains the decided variation and the reason for the decision.
 */
export declare class Decision implements ParameterConfig {
    readonly variation: VariationKey;
    readonly reason: DecisionReason;
    readonly config: ParameterConfig;
    readonly experiment: HackleExperiment | undefined;
    constructor(variation: VariationKey, reason: DecisionReason, config: ParameterConfig, experiment: HackleExperiment | undefined);
    static of(variation: VariationKey, reason: DecisionReason, config?: ParameterConfig, experiment?: HackleExperiment | undefined): Decision;
    get parameters(): Record<string, string | number | boolean>;
    get(key: string, defaultValue: string): string;
    get(key: string, defaultValue: number): number;
    get(key: string, defaultValue: boolean): boolean;
}
/**
 * An object that contains the decided flag and the reason for the feature flag decision.
 */
export declare class FeatureFlagDecision implements ParameterConfig {
    readonly isOn: boolean;
    readonly reason: DecisionReason;
    readonly config: ParameterConfig;
    readonly experiment: HackleExperiment | undefined;
    constructor(isOn: boolean, reason: DecisionReason, config: ParameterConfig, experiment: HackleExperiment | undefined);
    static on(reason: DecisionReason, config?: ParameterConfig, experiment?: HackleExperiment | undefined): FeatureFlagDecision;
    static off(reason: DecisionReason, config?: ParameterConfig, experiment?: HackleExperiment | undefined): FeatureFlagDecision;
    get parameters(): Record<string, string | number | boolean>;
    get(key: string, defaultValue: string): string;
    get(key: string, defaultValue: number): number;
    get(key: string, defaultValue: boolean): boolean;
}
export interface Config {
    get(key: string, defaultValue: string): string;
    get(key: string, defaultValue: number): number;
    get(key: string, defaultValue: boolean): boolean;
}
/**
 * An interface model for remote Config
 */
export interface HackleRemoteConfig extends Config {
}
export declare class EmptyHackleRemoteConfig implements HackleRemoteConfig {
    get(key: string, defaultValue: string): string;
    get(key: string, defaultValue: number): number;
    get(key: string, defaultValue: boolean): boolean;
}
export declare class ParameterConfiguration implements ParameterConfig {
    id: Long;
    private readonly config;
    constructor(id: Long, config: ParameterConfig);
    get parameters(): Record<string, string | number | boolean>;
    static fromJson(dto: ParameterConfigurationDto): ParameterConfiguration;
    get(key: string, defaultValue: string): string;
    get(key: string, defaultValue: number): number;
    get(key: string, defaultValue: boolean): boolean;
}
/**
 * Describes the reason for the [Variation] decision.
 */
export declare class DecisionReason {
    static SDK_NOT_READY: string;
    static EXCEPTION: string;
    static INVALID_INPUT: string;
    static UNSUPPORTED_PLATFORM: string;
    static TYPE_MISMATCH: string;
    static EXPERIMENT_NOT_FOUND: string;
    static EXPERIMENT_DRAFT: string;
    static EXPERIMENT_PAUSED: string;
    static EXPERIMENT_COMPLETED: string;
    static OVERRIDDEN: string;
    static TRAFFIC_NOT_ALLOCATED: string;
    static NOT_IN_MUTUAL_EXCLUSION_EXPERIMENT: string;
    static IDENTIFIER_NOT_FOUND: string;
    static VARIATION_DROPPED: string;
    static TRAFFIC_ALLOCATED: string;
    static TRAFFIC_ALLOCATED_BY_TARGETING: string;
    static NOT_IN_EXPERIMENT_TARGET: string;
    static FEATURE_FLAG_NOT_FOUND: string;
    static FEATURE_FLAG_INACTIVE: string;
    static INDIVIDUAL_TARGET_MATCH: string;
    static TARGET_RULE_MATCH: string;
    static DEFAULT_RULE: string;
    static REMOTE_CONFIG_PARAMETER_NOT_FOUND: string;
    static IN_APP_MESSAGE_NOT_FOUND: string;
    static IN_APP_MESSAGE_DRAFT: string;
    static IN_APP_MESSAGE_PAUSED: string;
    static IN_APP_MESSAGE_HIDDEN: string;
    static IN_APP_MESSAGE_TARGET: string;
    static NOT_IN_IN_APP_MESSAGE_PERIOD: string;
    static NOT_IN_IN_APP_MESSAGE_TIMETABLE: string;
    static NOT_IN_IN_APP_MESSAGE_TARGET: string;
    static IN_APP_MESSAGE_FREQUENCY_CAPPED: string;
    static EXPERIMENT_CONTROL_GROUP: string;
}
export declare const EXPERIMENT_IMPLEMENTATION_TYPE: readonly ["DEFAULT", "SPLIT_URL", "IN_APP_MESSAGE"];
export declare type ExperimentType = "AB_TEST" | "FEATURE_FLAG";
export declare type ExperimentStatus = "DRAFT" | "RUNNING" | "PAUSED" | "COMPLETED";
export declare type ExperimentImplementationType = typeof EXPERIMENT_IMPLEMENTATION_TYPE[number];
export declare class Experiment implements HackleExperiment {
    readonly id: ExperimentId;
    readonly key: ExperimentKey;
    readonly type: ExperimentType;
    readonly identifierType: string;
    readonly status: ExperimentStatus;
    readonly version: Long;
    readonly executionVersion: Long;
    readonly variations: Variation[];
    readonly userOverrides: Map<UserId, VariationId>;
    readonly segmentOverrides: TargetRule[];
    readonly targetAudiences: Target[];
    readonly splitUrlTargets: SplitUrlTargets | undefined;
    readonly targetRules: TargetRule[];
    readonly defaultRule: TargetAction;
    readonly containerId: Long | undefined;
    readonly implementationType: ExperimentImplementationType;
    private readonly winnerVariationId;
    static fromJson(type: ExperimentType, dto: ExperimentDto, configs: ParameterConfiguration[]): Experiment | undefined;
    private static experimentStatusOrNull;
    constructor(id: ExperimentId, key: ExperimentKey, type: ExperimentType, identifierType: string, status: ExperimentStatus, version: Long, executionVersion: Long, variations: Variation[], userOverrides: Map<UserId, VariationId>, segmentOverrides: TargetRule[], targetAudiences: Target[], splitUrlTargets: SplitUrlTargets | undefined, targetRules: TargetRule[], defaultRule: TargetAction, containerId: Long | undefined, implementationType: ExperimentImplementationType, winnerVariationId: VariationId | undefined);
    _winnerVariationOrNull(): Variation | undefined;
    _getVariationByIdOrNull(variationId: VariationId): Variation | undefined;
    _getVariationByKeyOrNull(variationKey: VariationKey): Variation | undefined;
}
export declare class Variation implements HackleVariation {
    readonly id: VariationId;
    readonly key: VariationKey;
    readonly isDropped: boolean;
    readonly config: ParameterConfiguration | undefined;
    constructor(id: VariationId, key: VariationKey, isDropped: boolean, config: ParameterConfiguration | undefined);
    get parameters(): Record<string, string | number | boolean>;
}
export declare class Bucket {
    id: number;
    seed: number;
    slotSize: number;
    slots: Slot[];
    constructor(id: number, seed: number, slotSize: number, slots: Slot[]);
    static fromJson(dto: BucketDto): Bucket;
}
export declare class Slot {
    startInclusive: number;
    endExclusive: number;
    variationId: VariationId;
    constructor(startInclusive: number, endExclusive: number, variationId: VariationId);
    contains(slotNumber: number): boolean;
}
export declare class EventType {
    id: EventId;
    key: EventKey;
    constructor(id: EventId, key: EventKey);
    static fromJson(dto: EventTypeDto): EventType;
}
export interface HackleEvent<T = string> {
    key: string;
    value?: number;
    properties?: Properties<T>;
}
export interface HackleUser {
    identifiers: Identifiers;
    properties: Properties;
    hackleProperties: Properties;
    cohorts?: Cohort[];
    targetEvents?: UserTargetEvent[];
}
export declare class IdentifierType {
    static ID: string;
    static USER: string;
    static DEVICE: string;
    static SESSION: string;
    static HACKLE_DEVICE: string;
}
export interface User {
    id?: string;
    userId?: string;
    deviceId?: string;
    identifiers?: Identifiers;
    properties?: Properties;
}
export interface Identifier {
    readonly type: string;
    readonly value: string;
}
export interface Identifiers {
    [key: string]: string;
}
export declare const resolveIdentifiers: (user: User) => Identifiers;
export declare class IdentifiersBuilder {
    identifiers: Identifiers;
    addIdentifiers(identifiers: Identifiers): IdentifiersBuilder;
    add(type: string, value: any): IdentifiersBuilder;
    build(): Identifiers;
}
export declare type PropertyValue = string | boolean | number | Array<string | number> | null | undefined;
export declare const sanitizeUser: (user: any) => User | null;
export interface Properties<T = string | PropertyOperation> {
    [key: string | PropertyOperation]: T extends PropertyOperation ? Properties<string> : PropertyValue;
}
export declare class Target {
    static fromJson(dto: TargetDto, targetingType: TargetingType): Target | undefined;
    conditions: TargetCondition[];
    constructor(conditions: TargetCondition[]);
    toJson(): TargetDto;
}
export declare class TargetCondition {
    static fromJson(dto: TargetConditionDto, targetingType: TargetingType): TargetCondition | undefined;
    key: TargetKey;
    match: TargetMatch;
    constructor(key: TargetKey, match: TargetMatch);
    toJson(): TargetConditionDto;
}
export declare class TargetKey {
    static fromJson(dto: TargetKeyDto): TargetKey | undefined;
    type: TargetKeyType;
    name: string;
    constructor(type: TargetKeyType, name: string);
    toJson(): TargetKeyDto;
}
export declare class TargetMatch {
    static fromJson(dto: TargetMatchDto): TargetMatch | undefined;
    type: MatchType;
    operator: MatchOperator;
    valueType: MatchValueType;
    values: any[];
    constructor(type: MatchType, operator: MatchOperator, valueType: MatchValueType, values: any[]);
    toJson(): TargetMatchDto;
}
export declare class TargetAction {
    static fromJson(dto: TargetActionDto): TargetAction | undefined;
    type: TargetActionType;
    variationId: number | undefined;
    bucketId: number | undefined;
    constructor(type: TargetActionType, variationId: number | undefined, bucketId: number | undefined);
}
export declare class TargetRule {
    static fromJson(dto: TargetRuleDto, targetingType: TargetingType): TargetRule | undefined;
    target: Target;
    action: TargetAction;
    constructor(target: Target, action: TargetAction);
}
export declare class Segment {
    static fromJson(dto: SegmentDto): Segment | undefined;
    id: Long;
    key: SegmentKey;
    type: SegmentType;
    targets: Target[];
    constructor(id: Long, key: SegmentKey, type: SegmentType, targets: Target[]);
}
export declare class Container {
    id: Long;
    bucketId: Long;
    groups: ContainerGroup[];
    constructor(id: Long, bucketId: Long, groups: ContainerGroup[]);
    static fromJson(dto: ContainerDto): Container;
    getGroupOrNull(containerGroupId: Long): ContainerGroup | undefined;
}
export declare class ContainerGroup {
    static fromJson(dto: ContainerGroupDto): ContainerGroup;
    id: Long;
    experiments: Long[];
    constructor(id: Long, experiments: Long[]);
}
export declare class RemoteConfigParameter {
    id: Long;
    key: string;
    type: MatchValueType;
    identifierType: string;
    targetRules: RemoteConfigTargetRule[];
    defaultValue: RemoteConfigParameterValue;
    constructor(id: Long, key: string, type: MatchValueType, identifierType: string, targetRules: RemoteConfigTargetRule[], defaultValue: RemoteConfigParameterValue);
    static fromJson(dto: RemoteConfigParameterDto): RemoteConfigParameter | undefined;
}
export declare class RemoteConfigTargetRule {
    static fromJson(dto: RemoteConfigTargetRuleDto, targetingType: TargetingType): RemoteConfigTargetRule | undefined;
    key: string;
    name: string;
    target: Target;
    bucketId: Long;
    value: RemoteConfigParameterValue;
    constructor(key: string, name: string, target: Target, bucketId: Long, value: RemoteConfigParameterValue);
}
export declare class RemoteConfigParameterValue {
    static fromJson(dto: RemoteConfigParameterValueDto): RemoteConfigParameterValue;
    id: Long;
    rawValue: any;
    constructor(id: Long, rawValue: any);
}
export declare class Version {
    readonly coreVersion: CoreVersion;
    readonly prerelease: MetaVersion;
    readonly build: MetaVersion;
    constructor(coreVersion: CoreVersion, prerelease: MetaVersion, build: MetaVersion);
    static regExp: RegExp;
    static tryParse(value: any): Version | undefined;
    compareTo(other: Version): number;
    isEqualTo(other: Version): boolean;
    isGreaterThan(other: Version): boolean;
    isGreaterThanOrEqualTo(other: Version): boolean;
    isLessThan(other: Version): boolean;
    isLessThanOrEqualTo(other: Version): boolean;
}
export declare class CoreVersion {
    readonly major: number;
    readonly minor: number;
    readonly patch: number;
    constructor(major: number, minor: number, patch: number);
    compareTo(other: CoreVersion): number;
}
export declare class MetaVersion {
    readonly identifiers: string[];
    constructor(identifiers: string[]);
    private static EMPTY;
    static parse(text: string | undefined): MetaVersion;
    isEmpty(): boolean;
    isNotEmpty(): boolean;
    compareTo(other: MetaVersion): number;
    private compareIdentifiers;
    private static numericIdentifierRegExp;
    private static compareIdentifiers;
}
export declare type HackleValue = string | number | boolean;
export declare const MATCH_TYPES: readonly ["MATCH", "NOT_MATCH"];
export declare const MATCH_VALUE_TYPES: readonly ["STRING", "NUMBER", "BOOLEAN", "VERSION", "JSON", "URL", "NULL", "UNKNOWN"];
export declare const MATCH_OPERATORS: readonly ["IN", "CONTAINS", "STARTS_WITH", "ENDS_WITH", "GT", "GTE", "LT", "LTE", "EXISTS"];
export declare const TARGET_ACTION_TYPES: readonly ["VARIATION", "BUCKET"];
export declare const TARGET_KEY_TYPES: readonly ["USER_ID", "USER_PROPERTY", "HACKLE_PROPERTY", "SEGMENT", "AB_TEST", "FEATURE_FLAG", "EVENT_PROPERTY", "COHORT", "NUMBER_OF_EVENTS_IN_DAYS", "NUMBER_OF_EVENTS_WITH_PROPERTY_IN_DAYS"];
export declare const SEGMENT_TYPES: readonly ["USER_ID", "USER_PROPERTY"];
export declare type MatchType = typeof MATCH_TYPES[number];
export declare type MatchValueType = typeof MATCH_VALUE_TYPES[number];
export declare type MatchOperator = typeof MATCH_OPERATORS[number];
export declare type TargetActionType = typeof TARGET_ACTION_TYPES[number];
export declare type TargetKeyType = typeof TARGET_KEY_TYPES[number];
export declare type SegmentType = typeof SEGMENT_TYPES[number];
export declare class TargetingType {
    static IDENTIFIER: TargetingType;
    static PROPERTY: TargetingType;
    static SEGMENT: TargetingType;
    private supportedKeyTypes;
    constructor(...supportedKeyTypes: TargetKeyType[]);
    supports(keyType: TargetKeyType): boolean;
}
export declare const IAM_STATUS: readonly ["ACTIVE", "DRAFT", "PAUSE"];
export declare const IAM_PLATFORM_TYPE: readonly ["WEB", "ANDROID", "IOS"];
export declare const IAM_TIMEUNIT: readonly ["IMMEDIATE", "CUSTOM"];
export declare const IAM_DISPLAY_TYPE: readonly ["HTML", "MODAL", "BANNER", "BOTTOM_SHEET", "NONE"];
export declare const IAM_LAYOUT_TYPE: readonly ["IMAGE_TEXT", "IMAGE_ONLY", "TEXT_ONLY", "IMAGE", "NONE"];
export declare const IAM_ORIENTATION: readonly ["VERTICAL", "HORIZONTAL"];
export declare const IAM_BEHAVIOR: readonly ["CLICK"];
export declare const IAM_ACTION_TYPE: readonly ["CLOSE", "WEB_LINK", "HIDDEN", "LINK_AND_CLOSE", "LINK_NEW_TAB", "LINK_NEW_TAB_AND_CLOSE", "LINK_NEW_WINDOW", "LINK_NEW_WINDOW_AND_CLOSE"];
export declare const IAM_VERTICAL_ALIGNMENT: readonly ["TOP", "MIDDLE", "BOTTOM"];
export declare const IAM_HORIZONTAL_ALIGNMENT: readonly ["LEFT", "CENTER", "RIGHT"];
export declare const IAM_ACTION_AREA: readonly ["BUTTON", "IMAGE", "MESSAGE", "X_BUTTON"];
export declare const IAM_TIMETABLE_TYPE: readonly ["ALL", "CUSTOM"];
export declare const IAM_HTML_RESOURCE_TYPE: readonly ["TEXT", "PATH"];
export declare type InAppMessageStatus = typeof IAM_STATUS[number];
export declare type InAppMessagePlatformType = typeof IAM_PLATFORM_TYPE[number];
export declare type InAppMessageTimeUnit = typeof IAM_TIMEUNIT[number];
export declare type InAppMessageDisplayType = typeof IAM_DISPLAY_TYPE[number];
export declare type InAppMessageLayoutType = typeof IAM_LAYOUT_TYPE[number];
export declare type InAppMessageOrientation = typeof IAM_ORIENTATION[number];
export declare type InAppMessageBehavior = typeof IAM_BEHAVIOR[number];
export declare type InAppMessageActionType = typeof IAM_ACTION_TYPE[number];
export declare type InAppMessageActionArea = typeof IAM_ACTION_AREA[number];
export declare type InAppMessageVerticalAlignment = typeof IAM_VERTICAL_ALIGNMENT[number];
export declare type InAppMessageHorizontalAlignment = typeof IAM_HORIZONTAL_ALIGNMENT[number];
export declare type InAppMessageTimetableType = typeof IAM_TIMETABLE_TYPE[number];
export declare class InAppMessage {
    readonly id: number;
    readonly key: number;
    readonly status: InAppMessageStatus;
    readonly period: InAppMessagePeriod;
    readonly timetable: InAppMessageTimetable;
    readonly eventTrigger: InAppMessageEventTrigger;
    readonly targetContext: InAppMessageTargetContext;
    readonly messageContext: InAppMessageContext;
    readonly evaluateContext: InAppMessageEvaluateContext | null;
    constructor(id: number, key: number, status: InAppMessageStatus, period: InAppMessagePeriod, timetable: InAppMessageTimetable, eventTrigger: InAppMessageEventTrigger, targetContext: InAppMessageTargetContext, messageContext: InAppMessageContext, evaluateContext: InAppMessageEvaluateContext | null);
    static fromJson(dto: InAppMessageDto): InAppMessage | undefined;
    supports(platformType: InAppMessagePlatformType): boolean;
    toString(): string;
}
export interface InAppMessagePeriod {
    type: InAppMessageTimeUnit;
    startMillisInclusive?: number;
    endMillisExclusive?: number;
    within(timestamp: number): boolean;
}
export declare class InAppMessagePeriodAlways implements InAppMessagePeriod {
    type: InAppMessageTimeUnit;
    within(timestamp: number): boolean;
}
export declare class InAppMessagePeriodCustom implements InAppMessagePeriod {
    readonly startMillisInclusive: number;
    readonly endMillisExclusive: number;
    type: InAppMessageTimeUnit;
    constructor(startMillisInclusive: number, endMillisExclusive: number);
    within(timestamp: number): boolean;
}
export declare abstract class InAppMessageTimetable {
    abstract type: InAppMessageTimetableType;
    abstract within(timestamp: number): boolean;
    static fromJson(dto: InAppMessageTimetableDto): InAppMessageTimetable | undefined;
}
export declare class InAppMessageTimetableAll extends InAppMessageTimetable {
    type: InAppMessageTimetableType;
    within(_: number): boolean;
}
export declare class InAppMessageTimetableCustom extends InAppMessageTimetable {
    private readonly slots;
    type: InAppMessageTimetableType;
    constructor(slots: InAppMessageTimetableSlot[]);
    within(timestamp: number): boolean;
}
export declare class InAppMessageTimetableSlot {
    private readonly dayOfWeek;
    private readonly startMillisInclusive;
    private readonly endMillisExclusive;
    constructor(dayOfWeek: DayOfWeek, startMillisInclusive: number, endMillisExclusive: number);
    within(timestamp: number): boolean;
    static fromJson(dto: InAppMessageTimetableSlotDto): InAppMessageTimetableSlot | undefined;
}
export declare class InAppMessageEventTrigger {
    readonly rules: InAppMessageEventTriggerRule[];
    readonly frequencyCap: InAppMessageEventFrequencyCap | null;
    readonly delay: Delay;
    constructor(rules: InAppMessageEventTriggerRule[], frequencyCap: InAppMessageEventFrequencyCap | null, delay: Delay);
}
export declare class InAppMessageEventTriggerRule {
    readonly eventKey: string;
    readonly targets: Target[];
    constructor(eventKey: string, targets: Target[]);
    static fromJson(dto: InAppMessageEventTriggerRuleDto): InAppMessageEventTriggerRule;
}
export declare class InAppMessageEventFrequencyCap {
    readonly identifierCaps: InAppMessageIdentifierCap[];
    readonly durationCap: InAppMessageDurationCap | null;
    constructor(identifierCaps: InAppMessageIdentifierCap[], durationCap: InAppMessageDurationCap | null);
    static fromJson(dto?: InAppMessageEventFrequencyCapDto): InAppMessageEventFrequencyCap | null;
}
export declare class InAppMessageIdentifierCap {
    readonly identifierType: string;
    readonly count: number;
    constructor(identifierType: string, count: number);
    static fromJson(dto: InAppMessageIdentifierCapDto): InAppMessageIdentifierCap;
}
export declare class InAppMessageDurationCap {
    readonly durationMillis: number;
    readonly count: number;
    constructor(durationMillis: number, count: number);
    static fromJson(dto?: InAppMessageDurationCapDto): InAppMessageDurationCap | null;
}
export declare class InAppMessageTargetContext {
    readonly overrides: InAppMessageUserOverride[];
    readonly targets: Target[];
    constructor(overrides: InAppMessageUserOverride[], targets: Target[]);
    static fromJson(dto: InAppMessageTargetContextDto): InAppMessageTargetContext;
}
export declare class InAppMessageUserOverride {
    readonly identifierType: string;
    readonly identifiers: string[];
    constructor(identifierType: string, identifiers: string[]);
    static fromJson(dto: InAppMessageTargetRuleOverrideDto): InAppMessageUserOverride;
}
export declare class InAppMessageContext {
    readonly defaultLang: string;
    readonly experimentContext: InAppMessageExperimentContext | null;
    readonly platformTypes: InAppMessagePlatformType[];
    readonly orientations: InAppMessageOrientation[];
    readonly messages: InAppMessageContextMessage[];
    constructor(defaultLang: string, experimentContext: InAppMessageExperimentContext | null, platformTypes: InAppMessagePlatformType[], orientations: InAppMessageOrientation[], messages: InAppMessageContextMessage[]);
    static fromJson(dto: InAppMessageContextDto): InAppMessageContext | undefined;
}
export declare class InAppMessageExperimentContext {
    readonly key: number;
    constructor(key: number);
}
export declare class InAppMessageContextMessage {
    readonly variationKey: string | null;
    readonly lang: string;
    readonly layout: InAppMessageContextLayout;
    readonly images: InAppMessageImage[];
    readonly imageAutoScroll: InAppMessageImageAutoScroll | undefined;
    readonly text: InAppMessageText | undefined;
    readonly buttons: InAppMessageButton[];
    readonly closeButton: InAppMessageButton | undefined;
    readonly background: InAppMessageBackground;
    readonly action: InAppMessageAction | undefined;
    readonly outerButtons: InAppMessagePositionalButton[];
    readonly innerButtons: InAppMessagePositionalButton[];
    readonly html: InAppMessageHtml | undefined;
    constructor(variationKey: string | null, lang: string, layout: InAppMessageContextLayout, images: InAppMessageImage[], imageAutoScroll: InAppMessageImageAutoScroll | undefined, text: InAppMessageText | undefined, buttons: InAppMessageButton[], closeButton: InAppMessageButton | undefined, background: InAppMessageBackground, action: InAppMessageAction | undefined, outerButtons: InAppMessagePositionalButton[], innerButtons: InAppMessagePositionalButton[], html: InAppMessageHtml | undefined);
    static fromJson(dto: InAppMessageContextMessageDto): InAppMessageContextMessage | undefined;
    toJson(): InAppMessageContextMessageDto;
}
export declare class InAppMessageContextLayout {
    readonly displayType: InAppMessageDisplayType;
    readonly layoutType: InAppMessageLayoutType;
    readonly alignment: InAppMessageAlignment | undefined;
    constructor(displayType: InAppMessageDisplayType, layoutType: InAppMessageLayoutType, alignment: InAppMessageAlignment | undefined);
    static fromJson(dto: InAppMessageLayoutDto): InAppMessageContextLayout | undefined;
}
export declare class InAppMessageAlignment {
    readonly horizontal: InAppMessageHorizontalAlignment;
    readonly vertical: InAppMessageVerticalAlignment;
    constructor(horizontal: InAppMessageHorizontalAlignment, vertical: InAppMessageVerticalAlignment);
    static fromJson(dto: InAppMessageAlignmentDto): InAppMessageAlignment | undefined;
    toJson(): InAppMessageAlignmentDto;
}
export declare class InAppMessageImage {
    readonly orientation: InAppMessageOrientation;
    readonly imagePath: string;
    readonly action: InAppMessageAction | undefined;
    constructor(orientation: InAppMessageOrientation, imagePath: string, action: InAppMessageAction | undefined);
    static fromJson(dto: InAppMessageContextImageDto): InAppMessageImage | undefined;
    toJson(): InAppMessageContextImageDto;
}
export declare class InAppMessageImageAutoScroll {
    readonly intervalMillis: number;
    constructor(intervalMillis: number);
    static fromJson(dto: InAppMessageContextImageAutoScrollDto): InAppMessageImageAutoScroll | undefined;
    toJson(): InAppMessageContextImageAutoScrollDto;
}
export declare class InAppMessageText {
    readonly title: InAppMessageTextAttribute;
    readonly body: InAppMessageTextAttribute;
    constructor(title: InAppMessageTextAttribute, body: InAppMessageTextAttribute);
    static fromJson(dto: InAppMessageContextTextDto): InAppMessageText;
    toJson(): InAppMessageContextTextDto;
}
export declare class InAppMessageTextAttribute {
    readonly text: string;
    readonly style: InAppMessageTextStyle;
    constructor(text: string, style: InAppMessageTextStyle);
    static fromJson(dto: InAppMessageContextTextContentDto): InAppMessageTextAttribute;
}
export declare class InAppMessageTextStyle {
    readonly color: string;
    constructor(color: string);
}
export declare class InAppMessageButton {
    readonly text: string;
    readonly style: InAppMessageButtonStyle;
    readonly action: InAppMessageAction;
    constructor(text: string, style: InAppMessageButtonStyle, action: InAppMessageAction);
    static fromJson(dto: InAppMessageContextButtonDto): InAppMessageButton | undefined;
    static fromJson2(dto: InAppMessageContextCloseButtonDto): InAppMessageButton | undefined;
    toJson(): InAppMessageContextButtonDto;
    toCloseButtonJson(): InAppMessageContextCloseButtonDto;
}
export declare class InAppMessagePositionalButton {
    readonly button: InAppMessageButton;
    readonly alignment: InAppMessageAlignment;
    constructor(button: InAppMessageButton, alignment: InAppMessageAlignment);
    static fromJson(dto: InAppMessagePositionalButtonDto): InAppMessagePositionalButton | undefined;
    toJson(): InAppMessagePositionalButtonDto;
}
export declare class InAppMessageButtonStyle {
    readonly textColor: string;
    readonly backgroundColor: string;
    readonly borderColor: string;
    constructor(textColor: string, backgroundColor: string, borderColor: string);
}
export declare class InAppMessageBackground {
    readonly color: string;
    constructor(color: string);
}
export declare class InAppMessageAction {
    readonly behavior: InAppMessageBehavior;
    readonly type: InAppMessageActionType;
    readonly value: string | undefined;
    private static readonly DEFAULT_HIDE_DURATION_MILLIS;
    constructor(behavior: InAppMessageBehavior, type: InAppMessageActionType, value: string | undefined);
    get hideDurationMillis(): number | null;
    static fromJson(dto: InAppMessageContextActionDto): InAppMessageAction | undefined;
    toJson(): InAppMessageContextActionDto;
}
export declare class InAppMessageEvaluateContext {
    readonly atDeliverTime: boolean;
    constructor(atDeliverTime: boolean);
    static fromJson(dto: InAppMessageEvaluateContextDto): InAppMessageEvaluateContext;
}
export declare class InAppMessageAfterCondition {
    readonly durationMillis: number;
    constructor(durationMillis: number);
    static fromJson(dto: InAppMessageAfterConditionDto): InAppMessageAfterCondition | null;
}
export declare class Delay {
    readonly type: "IMMEDIATE" | "AFTER";
    readonly afterCondition: InAppMessageAfterCondition | null;
    constructor(type: "IMMEDIATE" | "AFTER", afterCondition: InAppMessageAfterCondition | null);
    static fromJson(dto: InAppMessageDelayDto): Delay;
    static immediate(): Delay;
    deliverAt(startedAt: number): number;
}
export declare type InAppMessageHtml = InAppMessageHtmlText | InAppMessageHtmlPath;
export declare class InAppMessageHtmlText {
    readonly text: string;
    readonly resourceType = "TEXT";
    readonly path: null;
    constructor(text: string);
    toJson(): InAppMessageHtmlDto;
}
export declare class InAppMessageHtmlPath {
    readonly path: string;
    readonly resourceType = "PATH";
    readonly text: null;
    constructor(path: string);
    toJson(): InAppMessageHtmlDto;
}
export declare class InAppMessageHtmlFactory {
    static fromJson(dto: InAppMessageHtmlDto): InAppMessageHtml | undefined;
}
export declare class Cohort {
    readonly id: number;
    constructor(id: number);
}
export interface Sdk {
    readonly key: string;
    readonly name: string;
    readonly version: string;
}
export declare enum SplitUrlRedirectType {
    MANUAL = "MANUAL"
}
export declare class SplitUrlConfig {
    readonly needRedirect: boolean;
    readonly redirectType: SplitUrlRedirectType | null;
    readonly redirectUrl: string | null;
    constructor(needRedirect: boolean, redirectType: SplitUrlRedirectType | null, redirectUrl: string | null);
    static fromDto(dto: SplitUrlConfigDto): SplitUrlConfig;
}
export declare class SplitUrlTargets {
    readonly includeTargets: Target[];
    readonly excludeTargets: Target[];
    static fromJson(dto: ExecutionTargetUrlsDto | null): SplitUrlTargets | undefined;
    constructor(includeTargets: Target[], excludeTargets: Target[]);
}
export declare class UserTargetEvent {
    readonly eventKey: string;
    readonly property: UserTargetEventPropertyDto | null;
    readonly stats: UserTargetStatDto[];
    constructor(eventKey: string, property: UserTargetEventPropertyDto | null, stats: UserTargetStatDto[]);
    static fromJson(dto: UserTargetEventDto): UserTargetEvent;
    countWithinDays(daysAgoUtc: number): number;
}
export declare type UserTargetEventSupportedTargetKey = "NUMBER_OF_EVENTS_IN_DAYS" | "NUMBER_OF_EVENTS_WITH_PROPERTY_IN_DAYS";
export interface NumberOfEventsInDaysExpression {
    eventKey: string;
    days: number;
}
export interface NumberOfEventsWithPropertyInDaysExpression {
    eventKey: string;
    days: number;
    propertyFilter: TargetCondition;
}
export declare type TargetSegmentationExpression = NumberOfEventsInDaysExpression | NumberOfEventsWithPropertyInDaysExpression;