ng-configcat-publicapi-ui 3.0.8 → 4.0.0

package/lib/setting-list/setting/rollout-percentage-items/rollout-percentage-items.component.d.ts

@@ -23,5 +23,5 @@ export declare class RolloutPercentageItemsComponent {
     getRolloutPercentageItemFormGroups(): UntypedFormGroup[];
     getPercentageFormControl(rolloutPercentageItem: any): UntypedFormControl;
     static ɵfac: i0.ɵɵFactoryDeclaration<RolloutPercentageItemsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RolloutPercentageItemsComponent, "configcat-rollout-percentage-items", never, { "formGroup": "formGroup"; "readOnly": "readOnly"; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RolloutPercentageItemsComponent, "configcat-rollout-percentage-items", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; }, {}, never, never, false, never>;
 }

package/lib/setting-list/setting/rollout-rules/rollout-rules.component.d.ts

@@ -32,7 +32,7 @@ export declare class RolloutRulesComponent {
     onDrop(event: any): void;
     attributeChanged(event: any, comparisonAttribute: UntypedFormControl): void;
     getPlaceHolder(rolloutRule: any): "" | "e.g: user_id1, user_id2, user_id3" | "e.g: jane@example.com, john@example.com" | "e.g: France, Brazil" | "e.g: value1, value2, value3" | "part-of-id" | "e.g: @example.com" | "e.g: United" | "e.g: any-part-of-your-value-string" | "e.g: 1.0.0, 2.0.1" | "e.g: 1.0.0" | "e.g: 42";
-    getComparisonValueType(rolloutRule: any): "text" | "number";
+    getComparisonValueType(rolloutRule: any): "number" | "text";
     getInfoClass(rolloutRule: any): "warn" | "info";
     getInfoTooltip(rolloutRule: any): "Learn more about comparators" | "Consider using sensitive text comparators. Click to learn more." | "Click to learn more about comparators";
     comparatorChanged(rolloutRule: any): void;
@@ -41,12 +41,12 @@ export declare class RolloutRulesComponent {
         validateSemVer: {
             valid: boolean;
         };
-    } | null;
+    };
     validateSemVerList(c: UntypedFormControl): {
         validateSemVerList: {
             valid: boolean;
         };
-    } | null;
+    };
     popOut(rolloutRule: any): void;
     trackByIndex(index: number): any;
     getRolloutRuleValueFormControl(rolloutRule: any): UntypedFormControl;
@@ -57,5 +57,5 @@ export declare class RolloutRulesComponent {
     getRolloutRuleSegmentComparatorFormControl(rolloutRule: any): UntypedFormControl;
     getRolloutRuleSegmentIdFormControl(rolloutRule: any): UntypedFormControl;
     static ɵfac: i0.ɵɵFactoryDeclaration<RolloutRulesComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RolloutRulesComponent, "configcat-rollout-rules", never, { "formGroup": "formGroup"; "readOnly": "readOnly"; "segments": "segments"; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RolloutRulesComponent, "configcat-rollout-rules", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; }, {}, never, never, false, never>;
 }

package/lib/setting-list/setting/setting.component.d.ts

@@ -39,5 +39,5 @@ export declare class SettingComponent implements OnInit {
     deleteSetting(): void;
     getDashboardUrl(): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<SettingComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SettingComponent, "setting", never, { "dashboardBasePath": "dashboardBasePath"; "productId": "productId"; "environmentId": "environmentId"; "configId": "configId"; "formGroup": "formGroup"; "readOnly": "readOnly"; "canDeleteSetting": "canDeleteSetting"; "deleteSettingText": "deleteSettingText"; "showEnvironmentName": "showEnvironmentName"; "segments": "segments"; }, { "deleteSettingRequested": "deleteSettingRequested"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SettingComponent, "setting", never, { "dashboardBasePath": { "alias": "dashboardBasePath"; "required": false; }; "productId": { "alias": "productId"; "required": false; }; "environmentId": { "alias": "environmentId"; "required": false; }; "configId": { "alias": "configId"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "canDeleteSetting": { "alias": "canDeleteSetting"; "required": false; }; "deleteSettingText": { "alias": "deleteSettingText"; "required": false; }; "showEnvironmentName": { "alias": "showEnvironmentName"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; }, { "deleteSettingRequested": "deleteSettingRequested"; }, never, never, false, never>;
 }

package/lib/setting-list/setting/value/value.component.d.ts

@@ -16,5 +16,5 @@ export declare class ValueComponent {
     popOut(): void;
     formatDecimalNumber(value: number): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<ValueComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ValueComponent, "configcat-value", never, { "valueFormControl": "valueFormControl"; "setting": "setting"; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ValueComponent, "configcat-value", never, { "valueFormControl": { "alias": "valueFormControl"; "required": false; }; "setting": { "alias": "setting"; "required": false; }; }, {}, never, never, false, never>;
 }

package/lib/setting-list/setting-list.component.d.ts

@@ -49,5 +49,5 @@ export declare class SettingListComponent implements OnChanges, OnDestroy {
         setting: SettingModel;
     }): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SettingListComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SettingListComponent, "configcat-setting-list", never, { "productId": "productId"; "environmentId": "environmentId"; "configId": "configId"; "dashboardBasePath": "dashboardBasePath"; "canDeleteSetting": "canDeleteSetting"; "onSave": "onSave"; "loadSettingValues": "loadSettingValues"; "loadSegments": "loadSegments"; "deleteSettingText": "deleteSettingText"; "showEnvironmentName": "showEnvironmentName"; }, { "loadSucceeded": "loadSucceeded"; "deleteSettingRequested": "deleteSettingRequested"; "formValuesChanged": "formValuesChanged"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SettingListComponent, "configcat-setting-list", never, { "productId": { "alias": "productId"; "required": false; }; "environmentId": { "alias": "environmentId"; "required": false; }; "configId": { "alias": "configId"; "required": false; }; "dashboardBasePath": { "alias": "dashboardBasePath"; "required": false; }; "canDeleteSetting": { "alias": "canDeleteSetting"; "required": false; }; "onSave": { "alias": "onSave"; "required": false; }; "loadSettingValues": { "alias": "loadSettingValues"; "required": false; }; "loadSegments": { "alias": "loadSegments"; "required": false; }; "deleteSettingText": { "alias": "deleteSettingText"; "required": false; }; "showEnvironmentName": { "alias": "showEnvironmentName"; "required": false; }; }, { "loadSucceeded": "loadSucceeded"; "deleteSettingRequested": "deleteSettingRequested"; "formValuesChanged": "formValuesChanged"; }, never, never, false, never>;
 }

package/lib/v2/feature-flag/date-time-picker/date-time-picker.component.d.ts

@@ -0,0 +1,25 @@
+import { DestroyRef, OnInit } from '@angular/core';
+import { ControlValueAccessor, FormControl, FormGroup, ValidationErrors, Validator } from '@angular/forms';
+import { FormHelper } from '../../../_services/form-helper';
+import * as i0 from "@angular/core";
+export interface DateTimeForm {
+    dateValue: FormControl<Date | undefined>;
+    timeValue: FormControl<string>;
+}
+export declare class DateTimePickerComponent implements OnInit, ControlValueAccessor, Validator {
+    FormHelper: typeof FormHelper;
+    destroyRef: DestroyRef;
+    formGroup: FormGroup<DateTimeForm>;
+    private onChangeModel;
+    private onTouchModel;
+    dateTooltip: string;
+    timeTooltip: string;
+    ngOnInit(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    validate(): ValidationErrors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimePickerComponent, "app-date-time-picker", never, { "dateTooltip": { "alias": "dateTooltip"; "required": false; }; "timeTooltip": { "alias": "timeTooltip"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/v2/feature-flag/dependees-dialog/dependees-dialog.component.d.ts

@@ -0,0 +1,27 @@
+import { IDependeeSetting } from '../../../_models/setting-value-formgroup';
+import { Router } from '@angular/router';
+import { PublicApiService } from '../../../_services';
+import * as i0 from "@angular/core";
+export declare class DependeesDialogComponent {
+    data: {
+        dependees: IDependeeSetting[];
+        name: string;
+        organizationId: string;
+        productId: string;
+        configId: string;
+        environmentId: string;
+    };
+    private router;
+    private publicApiService;
+    constructor(data: {
+        dependees: IDependeeSetting[];
+        name: string;
+        organizationId: string;
+        productId: string;
+        configId: string;
+        environmentId: string;
+    }, router: Router, publicApiService: PublicApiService);
+    getDashboardUrl(settingId: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DependeesDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DependeesDialogComponent, "app-dependees-dialog", never, {}, {}, never, never, false, never>;
+}

package/lib/v2/feature-flag/evaluation-formula/evaluation-formula.component.d.ts

@@ -0,0 +1,41 @@
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { ISegment, UpdateSettingValueForm, TargetingRuleForm, FormGenerator, IFeatureFlagLimitations, IPrerequisiteChanged, IFlagState } from '../../../bootstrap';
+import * as i0 from "@angular/core";
+export declare class EvaluationFormulaComponent {
+    private formGenerator;
+    formGroup: FormGroup<UpdateSettingValueForm>;
+    segments: ISegment[];
+    flagState: IFlagState;
+    showVariationId: boolean;
+    featureFlagLimitations: IFeatureFlagLimitations;
+    canManageSegments: boolean;
+    showPercentageEvaluationAttribute: boolean;
+    createSegmentRequested: EventEmitter<any>;
+    manageSegmentsRequested: EventEmitter<any>;
+    addSegmentConditionRequestedWithoutSegments: EventEmitter<any>;
+    changePercentageEvaluationAttributeRequested: EventEmitter<any>;
+    subscriptionLimitReached: EventEmitter<any>;
+    prerequisiteConditionChanged: EventEmitter<IPrerequisiteChanged>;
+    recalcAddButtons: EventEmitter<any>;
+    constructor(formGenerator: FormGenerator);
+    addUserCondition(): boolean;
+    addSegmentCondition(): boolean;
+    addPrerequisiteFlagCondition(): boolean;
+    addPercentageOptions(): boolean;
+    addTargetingRuleFormGroup(formGroup: FormGroup<TargetingRuleForm>): boolean;
+    checkFeatureFlagLimitations(): boolean;
+    trackByIndex(index: number): any;
+    onDrop(event: CdkDragDrop<any>): void;
+    isDragDisabled(targetingRule: FormGroup<TargetingRuleForm>): boolean;
+    sortPredicate(): (index: number) => boolean;
+    sortPredicateFunction(index: number): boolean;
+    getChipText(): string;
+    getChipTooltip(): string;
+    remove(index: number): void;
+    subscriptionLimitReachedCalled(): void;
+    recalcPrerequisiteReferences(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EvaluationFormulaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EvaluationFormulaComponent, "app-evaluation-formula", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; "flagState": { "alias": "flagState"; "required": false; }; "showVariationId": { "alias": "showVariationId"; "required": false; }; "featureFlagLimitations": { "alias": "featureFlagLimitations"; "required": false; }; "canManageSegments": { "alias": "canManageSegments"; "required": false; }; "showPercentageEvaluationAttribute": { "alias": "showPercentageEvaluationAttribute"; "required": false; }; }, { "createSegmentRequested": "createSegmentRequested"; "manageSegmentsRequested": "manageSegmentsRequested"; "addSegmentConditionRequestedWithoutSegments": "addSegmentConditionRequestedWithoutSegments"; "changePercentageEvaluationAttributeRequested": "changePercentageEvaluationAttributeRequested"; "subscriptionLimitReached": "subscriptionLimitReached"; "prerequisiteConditionChanged": "prerequisiteConditionChanged"; "recalcAddButtons": "recalcAddButtons"; }, never, never, false, never>;
+}

package/lib/v2/feature-flag/evaluation-formula/feature-flag-value/feature-flag-value.component.d.ts

@@ -0,0 +1,18 @@
+import { FormGroup } from '@angular/forms';
+import { MatDialog } from '@angular/material/dialog';
+import { FormHelper, ValueForm, IFeatureFlagLimitations, FormGenerator, IFlagState } from '../../../../bootstrap';
+import * as i0 from "@angular/core";
+export declare class FeatureFlagValueComponent {
+    private dialog;
+    private formGenerator;
+    formGroup: FormGroup<ValueForm>;
+    flagState: IFlagState;
+    featureFlagLimitations: IFeatureFlagLimitations;
+    isPrerequisite: boolean;
+    tooltip: string;
+    FormHelper: typeof FormHelper;
+    constructor(dialog: MatDialog, formGenerator: FormGenerator);
+    expandText(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureFlagValueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FeatureFlagValueComponent, "app-feature-flag-value", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "flagState": { "alias": "flagState"; "required": false; }; "featureFlagLimitations": { "alias": "featureFlagLimitations"; "required": false; }; "isPrerequisite": { "alias": "isPrerequisite"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/v2/feature-flag/evaluation-formula/popout-text-editor-dialog/popout-text-editor-dialog.component.d.ts

@@ -0,0 +1,30 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { FormControl, ValidatorFn } from '@angular/forms';
+import { MatDialogRef } from '@angular/material/dialog';
+import { Subscription } from 'rxjs';
+import { FormHelper } from '../../../../bootstrap';
+import * as i0 from "@angular/core";
+export interface PopoutTextEditorDialogData {
+    value: string;
+    readOnly: boolean;
+    validators: ValidatorFn[];
+    maxValueLength: number;
+    description: string;
+}
+export declare class PopoutTextEditorDialogComponent implements OnInit, OnDestroy {
+    dialogRef: MatDialogRef<PopoutTextEditorDialogComponent>;
+    data: PopoutTextEditorDialogData;
+    formControlSubscription: Subscription;
+    jsonData: string;
+    format: string;
+    formHelper: typeof FormHelper;
+    control: FormControl<string>;
+    constructor(dialogRef: MatDialogRef<PopoutTextEditorDialogComponent>, data: PopoutTextEditorDialogData);
+    ngOnInit(): void;
+    onJsonChanged(value: string): void;
+    ngOnDestroy(): void;
+    set(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoutTextEditorDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PopoutTextEditorDialogComponent, "app-popout-text-editor-dialog", never, {}, {}, never, never, false, never>;
+}

package/lib/v2/feature-flag/evaluation-formula/targeting-rule/conditions/condition-chip/condition-chip.component.d.ts

@@ -0,0 +1,10 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ConditionChipComponent implements OnInit {
+    targetingRuleIndex: number;
+    conditionIndex: number;
+    chipText: string;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionChipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConditionChipComponent, "app-condition-chip", never, { "targetingRuleIndex": { "alias": "targetingRuleIndex"; "required": false; }; "conditionIndex": { "alias": "conditionIndex"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/v2/feature-flag/evaluation-formula/targeting-rule/conditions/conditions.component.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from '@angular/core';
+import { FormArray, FormGroup } from '@angular/forms';
+import { IFlagState, IFeatureFlagLimitations, ConditionForm, FormGenerator, ISegment } from '../../../../../bootstrap';
+import * as i0 from "@angular/core";
+export declare class ConditionsComponent {
+    private formGenerator;
+    formArray: FormArray<FormGroup<ConditionForm>>;
+    segments: ISegment[];
+    flagState: IFlagState;
+    targetingRuleIndex: number;
+    canManageSegments: boolean;
+    featureFlagLimitations: IFeatureFlagLimitations;
+    createSegmentRequested: EventEmitter<any>;
+    manageSegmentsRequested: EventEmitter<any>;
+    addSegmentConditionRequestedWithoutSegments: EventEmitter<any>;
+    lastConditionDeleted: EventEmitter<any>;
+    subscriptionLimitReached: EventEmitter<any>;
+    prerequisiteConditionChanged: EventEmitter<any>;
+    constructor(formGenerator: FormGenerator);
+    addUserCondition(): void;
+    addSegmentCondition(): void;
+    addPrerequisiteFlagCondition(): void;
+    remove(index: number): void;
+    checkLimitations(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConditionsComponent, "app-conditions", never, { "formArray": { "alias": "formArray"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; "flagState": { "alias": "flagState"; "required": false; }; "targetingRuleIndex": { "alias": "targetingRuleIndex"; "required": false; }; "canManageSegments": { "alias": "canManageSegments"; "required": false; }; "featureFlagLimitations": { "alias": "featureFlagLimitations"; "required": false; }; }, { "createSegmentRequested": "createSegmentRequested"; "manageSegmentsRequested": "manageSegmentsRequested"; "addSegmentConditionRequestedWithoutSegments": "addSegmentConditionRequestedWithoutSegments"; "lastConditionDeleted": "lastConditionDeleted"; "subscriptionLimitReached": "subscriptionLimitReached"; "prerequisiteConditionChanged": "prerequisiteConditionChanged"; }, never, never, false, never>;
+}

package/lib/v2/feature-flag/evaluation-formula/targeting-rule/conditions/prerequisite-flag-condition/prerequisite-flag-condition.component.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { FormHelper, PrerequisiteComparator, IFeatureFlagLimitations, PrerequisiteFlagConditionForm, IPrerequisiteSetting, IValueModel, FormGenerator, SettingType } from '../../../../../../bootstrap';
+import * as i0 from "@angular/core";
+export declare class PrerequisiteFlagConditionComponent implements OnInit {
+    private formGenerator;
+    targetingRuleIndex: number;
+    conditionIndex: number;
+    formGroup: FormGroup<PrerequisiteFlagConditionForm>;
+    prerequisiteSettings: IPrerequisiteSetting[];
+    featureFlagLimitations: IFeatureFlagLimitations;
+    prerequisiteConditionChanged: EventEmitter<any>;
+    SettingType: {
+        Boolean: SettingType;
+        String: SettingType;
+        Int: SettingType;
+        Double: SettingType;
+    };
+    prerequisiteSettingType: SettingType;
+    FormHelper: typeof FormHelper;
+    prerequisiteComparators: {
+        value: PrerequisiteComparator;
+        label: string;
+    }[];
+    booleanPrerequisiteComparators: {
+        value: PrerequisiteComparator;
+        label: string;
+    }[];
+    constructor(formGenerator: FormGenerator);
+    ngOnInit(): void;
+    getSettingType(): SettingType;
+    prerequisiteSettingChanged(): void;
+    getDefaultValueModel(settingType: SettingType): IValueModel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrerequisiteFlagConditionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PrerequisiteFlagConditionComponent, "app-prerequisite-flag-condition", never, { "targetingRuleIndex": { "alias": "targetingRuleIndex"; "required": false; }; "conditionIndex": { "alias": "conditionIndex"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "prerequisiteSettings": { "alias": "prerequisiteSettings"; "required": false; }; "featureFlagLimitations": { "alias": "featureFlagLimitations"; "required": false; }; }, { "prerequisiteConditionChanged": "prerequisiteConditionChanged"; }, never, never, false, never>;
+}

package/lib/v2/feature-flag/evaluation-formula/targeting-rule/conditions/segment-condition/segment-condition.component.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { FormHelper, SegmentConditionForm, ISegment, SegmentComparator } from '../../../../../../bootstrap';
+import * as i0 from "@angular/core";
+export declare class SegmentConditionComponent {
+    targetingRuleIndex: number;
+    conditionIndex: number;
+    formGroup: FormGroup<SegmentConditionForm>;
+    segments: ISegment[];
+    canManageSegments: boolean;
+    createSegmentRequested: EventEmitter<any>;
+    manageSegmentsRequested: EventEmitter<any>;
+    FormHelper: typeof FormHelper;
+    segmentComparators: {
+        value: SegmentComparator;
+        label: string;
+    }[];
+    createSegment(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentConditionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentConditionComponent, "app-segment-condition", never, { "targetingRuleIndex": { "alias": "targetingRuleIndex"; "required": false; }; "conditionIndex": { "alias": "conditionIndex"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; "canManageSegments": { "alias": "canManageSegments"; "required": false; }; }, { "createSegmentRequested": "createSegmentRequested"; "manageSegmentsRequested": "manageSegmentsRequested"; }, never, never, false, never>;
+}

package/lib/v2/feature-flag/evaluation-formula/targeting-rule/conditions/user-condition/comparator-dialog/comparator-dialog.component.d.ts

@@ -0,0 +1,79 @@
+import { OnInit } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import { UserComparator } from '../../../../../../../bootstrap';
+import * as i0 from "@angular/core";
+declare enum ComparatorGroup {
+    Text = 0,
+    Number = 1,
+    Semver = 2,
+    DateTime = 3,
+    Array = 4
+}
+interface ComparatorItem {
+    value: UserComparator;
+    sensitiveValue?: UserComparator;
+    label: string;
+    description: string;
+    group: ComparatorGroup;
+}
+export declare class ComparatorDialogComponent implements OnInit {
+    dialogRef: MatDialogRef<ComparatorDialogComponent>;
+    data: any;
+    ComparatorGroup: typeof ComparatorGroup;
+    selectedGroup: ComparatorGroup;
+    selectedComparator: UserComparator;
+    isConfidential: boolean;
+    lastConfidentialValue: boolean;
+    confidentialEnabled: boolean;
+    UserComparator: {
+        IsOneOf: UserComparator;
+        IsNotOneOf: UserComparator;
+        ContainsAnyOf: UserComparator;
+        DoesNotContainAnyOf: UserComparator;
+        SemVerIsOneOf: UserComparator;
+        SemVerIsNotOneOf: UserComparator;
+        SemVerLess: UserComparator;
+        SemVerLessOrEquals: UserComparator;
+        SemVerGreater: UserComparator;
+        SemVerGreaterOrEquals: UserComparator;
+        NumberEquals: UserComparator;
+        NumberDoesNotEqual: UserComparator;
+        NumberLess: UserComparator;
+        NumberLessOrEquals: UserComparator;
+        NumberGreater: UserComparator;
+        NumberGreaterOrEquals: UserComparator;
+        SensitiveIsOneOf: UserComparator;
+        SensitiveIsNotOneOf: UserComparator;
+        DateTimeBefore: UserComparator;
+        DateTimeAfter: UserComparator;
+        SensitiveTextEquals: UserComparator;
+        SensitiveTextDoesNotEqual: UserComparator;
+        SensitiveTextStartsWithAnyOf: UserComparator;
+        SensitiveTextNotStartsWithAnyOf: UserComparator;
+        SensitiveTextEndsWithAnyOf: UserComparator;
+        SensitiveTextNotEndsWithAnyOf: UserComparator;
+        SensitiveArrayContainsAnyOf: UserComparator;
+        SensitiveArrayDoesNotContainAnyOf: UserComparator;
+        TextEquals: UserComparator;
+        TextDoesNotEqual: UserComparator;
+        TextStartsWithAnyOf: UserComparator;
+        TextNotStartsWithAnyOf: UserComparator;
+        TextEndsWithAnyOf: UserComparator;
+        TextNotEndsWithAnyOf: UserComparator;
+        ArrayContainsAnyOf: UserComparator;
+        ArrayDoesNotContainAnyOf: UserComparator;
+    };
+    comparisonAttributeTooltip: string;
+    comparisonValueTooltip: string;
+    comparators: ComparatorItem[];
+    constructor(dialogRef: MatDialogRef<ComparatorDialogComponent>, data: any);
+    ngOnInit(): void;
+    listComparators(group: ComparatorGroup): ComparatorItem[];
+    changeGroup(group: ComparatorGroup): void;
+    confidentialChange(confidential: boolean): void;
+    comparatorChange(comp: UserComparator): void;
+    set(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComparatorDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComparatorDialogComponent, "app-comparator-dialog", never, {}, {}, never, never, false, never>;
+}
+export {};

package/lib/v2/feature-flag/evaluation-formula/targeting-rule/conditions/user-condition/popout-list-editor-dialog/popout-list-editor-dialog.component.d.ts

@@ -0,0 +1,63 @@
+import { AfterViewInit, DestroyRef, OnInit } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { MatDialogRef } from '@angular/material/dialog';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatTableDataSource } from '@angular/material/table';
+import { Subscription } from 'rxjs';
+import { FormHelper, IFeatureFlagLimitations, ComparisonValueForm, ComparisonValueListForm, FormGenerator, UserComparator, ComparisonValueListHelper, ComparisonValueListParseResult, IComparisonValueListModel } from '../../../../../../../bootstrap';
+import * as i0 from "@angular/core";
+export type PopoutListEditorDialogData = {
+    comparisonValueList: IComparisonValueListModel[];
+    comparator: UserComparator;
+    featureFlagLimitations: IFeatureFlagLimitations;
+    readOnly: boolean;
+};
+declare enum VisualizationType {
+    Table = 0,
+    Json = 1,
+    Csv = 2,
+    Csl = 3
+}
+export declare class PopoutListEditorDialogComponent implements OnInit, AfterViewInit {
+    private formGenerator;
+    dialogRef: MatDialogRef<PopoutListEditorDialogComponent>;
+    private comparisonValueListHelper;
+    data: PopoutListEditorDialogData;
+    destroyRef: DestroyRef;
+    FormHelper: typeof FormHelper;
+    VisualizationType: typeof VisualizationType;
+    dataSource: MatTableDataSource<FormGroup<ComparisonValueListForm>, MatPaginator>;
+    plainText: string;
+    formGroup: FormGroup<ComparisonValueForm>;
+    filterValue: string;
+    valueChanged: boolean;
+    currentlyHasHints: boolean;
+    displayedColumns: string[];
+    visualizationType: VisualizationType;
+    comparisonValueListParseResult: ComparisonValueListParseResult;
+    valueChangeSubscription: Subscription;
+    focusIndex: number;
+    paginator: MatPaginator;
+    set setPaginator(paginator: MatPaginator);
+    constructor(formGenerator: FormGenerator, dialogRef: MatDialogRef<PopoutListEditorDialogComponent>, comparisonValueListHelper: ComparisonValueListHelper, data: PopoutListEditorDialogData);
+    ngOnInit(): void;
+    setFormGroup(comparisonValueList: IComparisonValueListModel[]): void;
+    checkHasHints(): void;
+    setDataSource(): void;
+    ngAfterViewInit(): void;
+    applyFilter(): void;
+    add(): void;
+    remove(row: FormGroup<ComparisonValueListForm>): void;
+    set(): void;
+    close(): void;
+    removeAll(): void;
+    getRawValue(): IComparisonValueListModel[];
+    focusInvalid(): void;
+    changeVisualizationType(visualizationType: VisualizationType): void;
+    textValueChanged(): void;
+    recalculate(): void;
+    loadFile(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoutListEditorDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PopoutListEditorDialogComponent, "app-popout-list-editor-dialog", never, {}, {}, never, never, false, never>;
+}
+export {};

package/lib/v2/feature-flag/evaluation-formula/targeting-rule/conditions/user-condition/user-condition.component.d.ts

@@ -0,0 +1,94 @@
+import { ChangeDetectorRef, OnInit } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { MatChipInputEvent, MatChipEditedEvent, MatChipGrid } from '@angular/material/chips';
+import { MatDialog } from '@angular/material/dialog';
+import { ErrorStateMatcher } from '@angular/material/core';
+import { Clipboard } from '@angular/cdk/clipboard';
+import { FormHelper, ComparisonValueListForm, UserConditionForm, FormGenerator, UserComparator, UserComparatorText, UserComparatorType, IComparisonValueListModel, IFeatureFlagLimitations, ComparisonValueListHelper, MessagingService } from '../../../../../../bootstrap';
+import * as i0 from "@angular/core";
+export declare class ListValueErrorStateMatcher implements ErrorStateMatcher {
+    private formGroup;
+    constructor(formGroup: FormGroup<UserConditionForm>);
+    isErrorState(): boolean;
+}
+declare enum ComparatorGroup {
+    ConfidentialText = "CONFIDENTIAL TEXT",
+    Text = "TEXT",
+    SemanticVersion = "SEMANTIC VERSION",
+    Number = "NUMBER",
+    DateTime = "DATETIME",
+    ConfidentialArray = "CONFIDENTIAL ARRAY",
+    Array = "ARRAY"
+}
+interface IComparatorValue {
+    value: UserComparator;
+    label: UserComparatorText;
+    group: ComparatorGroup;
+    index: number;
+}
+export declare class UserConditionComponent implements OnInit {
+    private formGenerator;
+    private dialog;
+    private comparisonValueListHelper;
+    private clipboard;
+    private messagingService;
+    private changeDetectorRef;
+    readonly separatorKeysCodes: readonly [13, 188];
+    FormHelper: typeof FormHelper;
+    targetingRuleIndex: number;
+    conditionIndex: number;
+    readOnly: boolean;
+    featureFlagLimitations: IFeatureFlagLimitations;
+    formGroup: FormGroup<UserConditionForm>;
+    matChipGrid: MatChipGrid;
+    set setMatChipGrid(matChipGrid: MatChipGrid);
+    defaultComparisonAttributes: string[];
+    dateValue: Date;
+    timeValue: string;
+    comparatorSuggestions: Map<any, any>;
+    selectedComparator: UserComparator;
+    comparatorSeparator: string;
+    keepOrder: (a: any, _: any) => any;
+    RolloutRuleComparatorV2Type: typeof UserComparatorType;
+    rolloutRuleComparatorType: UserComparatorType;
+    isClearTextComparatorSelected: boolean;
+    fakeFormControl: FormControl<string>;
+    errorStateMatcher: ListValueErrorStateMatcher;
+    constructor(formGenerator: FormGenerator, dialog: MatDialog, comparisonValueListHelper: ComparisonValueListHelper, clipboard: Clipboard, messagingService: MessagingService, changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    attributeChanged(event: Event): void;
+    comparatorChanged(value: any): void;
+    compDialog(): void;
+    add(event: MatChipInputEvent): void;
+    remove(index: number): void;
+    edit(index: number, event: MatChipEditedEvent): void;
+    expandText(): void;
+    expandList(): void;
+    removeAll(): void;
+    copyValuesAsCsv(): void;
+    copyToClipboard(value: string): void;
+    getRawValue(): IComparisonValueListModel[];
+    isValueInvalid(listValueItemControl: FormGroup<ComparisonValueListForm>): boolean;
+    isHintInvalid(listValueItemControl: FormGroup<ComparisonValueListForm>): boolean;
+    isListValueItemInvalid(listValueItemControl: FormGroup<ComparisonValueListForm>): boolean;
+    getListValueItemTooltipMessage(listValueItemControl: FormGroup<ComparisonValueListForm>): string;
+    calcComparators(resetVal?: boolean): void;
+    buildComparatorSuggestions(ids: number[], resetVal: boolean): void;
+    dedupComps(comps: IComparatorValue[]): IComparatorValue[];
+    genSeparator(comps: IComparatorValue[]): string;
+    isNumberArr(val: any): boolean;
+    isNullCompVal(compVal: Partial<{
+        stringValue?: string;
+        doubleValue?: number;
+        listValue?: Partial<{
+            value: string;
+            hint?: string;
+            index: number;
+        }>[];
+    }>): boolean;
+    isClearTextComparator(comparator: UserComparator): boolean;
+    openCleartextInfoDialog(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserConditionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserConditionComponent, "app-user-condition", never, { "targetingRuleIndex": { "alias": "targetingRuleIndex"; "required": false; }; "conditionIndex": { "alias": "conditionIndex"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "featureFlagLimitations": { "alias": "featureFlagLimitations"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, {}, never, never, false, never>;
+}
+export {};

package/lib/v2/feature-flag/evaluation-formula/targeting-rule/percentage-options/percentage-options.component.d.ts

@@ -0,0 +1,31 @@
+import { EventEmitter } from '@angular/core';
+import { FormArray, FormGroup } from '@angular/forms';
+import { FormHelper, IFlagState, IFeatureFlagLimitations, PercentageOptionForm, FormGenerator, SettingType } from '../../../../../bootstrap';
+import * as i0 from "@angular/core";
+export declare class PercentageOptionsComponent {
+    private formGenerator;
+    formArray: FormArray<FormGroup<PercentageOptionForm>>;
+    flagState: IFlagState;
+    featureFlagLimitations: IFeatureFlagLimitations;
+    showPercentageEvaluationAttribute: boolean;
+    percentageEvaluationAttribute: string;
+    isPercentageOnlyTargetingRule: boolean;
+    lastPercentageOptionLeft: EventEmitter<any>;
+    subscriptionLimitReached: EventEmitter<any>;
+    changePercentageEvaluationAttributeRequested: EventEmitter<any>;
+    SettingType: {
+        Boolean: SettingType;
+        String: SettingType;
+        Int: SettingType;
+        Double: SettingType;
+    };
+    FormHelper: typeof FormHelper;
+    constructor(formGenerator: FormGenerator);
+    addOption(): void;
+    remove(index: number): void;
+    percentageChanged(index: number): void;
+    changePercentageEvaluationAttribute(): void;
+    getPercentageEvaluationAttribute(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PercentageOptionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PercentageOptionsComponent, "app-percentage-options", never, { "formArray": { "alias": "formArray"; "required": false; }; "flagState": { "alias": "flagState"; "required": false; }; "featureFlagLimitations": { "alias": "featureFlagLimitations"; "required": false; }; "showPercentageEvaluationAttribute": { "alias": "showPercentageEvaluationAttribute"; "required": false; }; "percentageEvaluationAttribute": { "alias": "percentageEvaluationAttribute"; "required": false; }; "isPercentageOnlyTargetingRule": { "alias": "isPercentageOnlyTargetingRule"; "required": false; }; }, { "lastPercentageOptionLeft": "lastPercentageOptionLeft"; "subscriptionLimitReached": "subscriptionLimitReached"; "changePercentageEvaluationAttributeRequested": "changePercentageEvaluationAttributeRequested"; }, never, never, false, never>;
+}

package/lib/v2/feature-flag/evaluation-formula/targeting-rule/targeting-rule.component.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { ISegment, TargetingRuleForm, FormGenerator, IFeatureFlagLimitations, IFlagState } from '../../../../bootstrap';
+import * as i0 from "@angular/core";
+export declare class TargetingRuleComponent {
+    private formGenerator;
+    formGroup: FormGroup<TargetingRuleForm>;
+    segments: ISegment[];
+    flagState: IFlagState;
+    targetingRuleIndex: number;
+    featureFlagLimitations: IFeatureFlagLimitations;
+    canManageSegments: boolean;
+    showPercentageEvaluationAttribute: boolean;
+    percentageEvaluationAttribute: string;
+    createSegmentRequested: EventEmitter<any>;
+    manageSegmentsRequested: EventEmitter<any>;
+    addSegmentConditionRequestedWithoutSegments: EventEmitter<any>;
+    removedAllRules: EventEmitter<any>;
+    subscriptionLimitReached: EventEmitter<any>;
+    changePercentageEvaluationAttributeRequested: EventEmitter<any>;
+    prerequisiteConditionChanged: EventEmitter<any>;
+    constructor(formGenerator: FormGenerator);
+    convertToPercentage(): void;
+    isPercentageOnly(): boolean;
+    showBadge(): boolean;
+    getChipText(): string;
+    getChipTooltip(): string;
+    lastPercentageOptionLeft(): void;
+    lastConditionDeleted(): void;
+    subscriptionLimitReachedCalled(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TargetingRuleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TargetingRuleComponent, "app-targeting-rule", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; "flagState": { "alias": "flagState"; "required": false; }; "targetingRuleIndex": { "alias": "targetingRuleIndex"; "required": false; }; "featureFlagLimitations": { "alias": "featureFlagLimitations"; "required": false; }; "canManageSegments": { "alias": "canManageSegments"; "required": false; }; "showPercentageEvaluationAttribute": { "alias": "showPercentageEvaluationAttribute"; "required": false; }; "percentageEvaluationAttribute": { "alias": "percentageEvaluationAttribute"; "required": false; }; }, { "createSegmentRequested": "createSegmentRequested"; "manageSegmentsRequested": "manageSegmentsRequested"; "addSegmentConditionRequestedWithoutSegments": "addSegmentConditionRequestedWithoutSegments"; "removedAllRules": "removedAllRules"; "subscriptionLimitReached": "subscriptionLimitReached"; "changePercentageEvaluationAttributeRequested": "changePercentageEvaluationAttributeRequested"; "prerequisiteConditionChanged": "prerequisiteConditionChanged"; }, never, never, false, never>;
+}