## API Report File for "NativeScript"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

// @public
export class AbsoluteLayout extends LayoutBase {
    // Warning: (ae-forgotten-export) The symbol "Length" needs to be exported by the entry point index.d.ts
    static getLeft(view: View): Length;

    static getTop(view: View): Length;

    static setLeft(view: View, value: Length): void;

    static setTop(view: View, value: Length): void;
}

// @public
export class ActionBar extends View {

    actionItems: ActionItems;

    // Warning: (ae-forgotten-export) The symbol "AndroidActionBarSettings" needs to be exported by the entry point index.d.ts
    android: AndroidActionBarSettings;

    // (undocumented)
    public effectiveContentInsetLeft: number;

    // (undocumented)
    public effectiveContentInsetRight: number;

    flat: boolean;

    // (undocumented)
    _getActualSize?: { width: number, height: number };

    ios: any /* UITabBarController */;

    iosIconRenderingMode: "automatic" | "alwaysOriginal" | "alwaysTemplate";

    // (undocumented)
    _isEmpty(): boolean;

    navigationButton: NavigationButton;

    title: string;

    titleView: View;

    update();
    //@endprivate
}

// @public
export class ActionItem extends ViewBase {
    actionBar: ActionBar;

    actionView: View;

    // Warning: (ae-forgotten-export) The symbol "AndroidActionItemSettings" needs to be exported by the entry point index.d.ts
    android: AndroidActionItemSettings;

    icon: string;

    // Warning: (ae-forgotten-export) The symbol "IOSActionItemSettings" needs to be exported by the entry point index.d.ts
    ios: IOSActionItemSettings;

    on(eventNames: string, callback: (data: EventData) => void);

    on(event: "tap", callback: (args: EventData) => void);

    // (undocumented)
    _raiseTap(): void;

    text: string;

    visibility: string;
}

// @public
export class ActionItems {
    addItem(item: ActionItem): void;

    getItemAt(index: number): ActionItem;

    getItems(): Array<ActionItem>;

    removeItem(item: ActionItem): void;
}

// @public
export class ActivityIndicator extends View {
    android: any /* android.widget.ProgressBar */;

    busy: boolean;

    ios: any /* UIActivityIndicatorView */;
}

// @public
export interface AndroidActivityBackPressedEventData extends AndroidActivityEventData {
    cancel: boolean;
}

// @public
export interface AndroidActivityBundleEventData extends AndroidActivityEventData {
    bundle: any /* android.os.Bundle */;
}

// @public
export interface AndroidActivityEventData {
    activity: any /* androidx.appcompat.app.AppCompatActivity */;

    eventName: string;

    object: any;
}

// @public
export interface AndroidActivityNewIntentEventData extends AndroidActivityEventData {
    intent: any /* android.content.Intent */;
}

// @public
export interface AndroidActivityRequestPermissionsEventData extends AndroidActivityEventData {
    grantResults: Array<number>;

    permissions: Array<string>;

    requestCode: number;
}

// @public
export interface AndroidActivityResultEventData extends AndroidActivityEventData {
    intent: any /* android.content.Intent */;

    requestCode: number;

    resultCode: number;
}

// @public
export class AndroidApplication extends Observable {
    public static activityBackPressedEvent: string;

    public static activityCreatedEvent: string;

    public static activityDestroyedEvent: string;

    public static activityNewIntentEvent: string;

    public static activityPausedEvent: string;

    public static activityRequestPermissionsEvent: string;

    public static activityResultEvent: string;

    public static activityResumedEvent: string;

    public static activityStartedEvent: string;

    public static activityStoppedEvent: string;

    context: any /* android.content.Context */;

    foregroundActivity: any /* androidx.appcompat.app.AppCompatActivity */;

    init: (nativeApp) => void;

    nativeApp: any /* android.app.Application */;

    on(eventNames: string, callback: (data: AndroidActivityEventData) => void, thisArg?: any);

    on(event: "activityCreated", callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any);

    on(event: "activityDestroyed", callback: (args: AndroidActivityEventData) => void, thisArg?: any);

    on(event: "activityStarted", callback: (args: AndroidActivityEventData) => void, thisArg?: any);

    on(event: "activityPaused", callback: (args: AndroidActivityEventData) => void, thisArg?: any);

    on(event: "activityResumed", callback: (args: AndroidActivityEventData) => void, thisArg?: any);

    on(event: "activityStopped", callback: (args: AndroidActivityEventData) => void, thisArg?: any);

    on(event: "saveActivityState", callback: (args: AndroidActivityBundleEventData) => void, thisArg?: any);

    on(event: "activityResult", callback: (args: AndroidActivityResultEventData) => void, thisArg?: any);

    on(event: "activityBackPressed", callback: (args: AndroidActivityBackPressedEventData) => void, thisArg?: any);

    on(event: "activityNewIntent", callback: (args: AndroidActivityNewIntentEventData) => void, thisArg?: any);

    on(event: "activityRequestPermissions", callback: (args: AndroidActivityRequestPermissionsEventData) => void, thisArg?: any);

    orientation: "portrait" | "landscape" | "unknown";

    packageName: string;

    paused: boolean;

    registerBroadcastReceiver(intentFilter: string, onReceiveCallback: (context: any /* android.content.Context */, intent: any /* android.content.Intent */) => void): void;

    public static saveActivityStateEvent: string;

    startActivity: any /* androidx.appcompat.app.AppCompatActivity */;

    systemAppearance: "dark" | "light";

    unregisterBroadcastReceiver(intentFilter: string): void;
}

// @public
export class Animation {
    constructor(animationDefinitions: Array<AnimationDefinition>, playSequentially?: boolean);
    // (undocumented)
    public cancel: () => void;
    // (undocumented)
    public isPlaying: boolean;
    // Warning: (ae-forgotten-export) The symbol "AnimationPromise" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public play: (resetOnFinish?: boolean) => AnimationPromise;
    // (undocumented)
    public _resolveAnimationCurve(curve: any): any;
}

// @public
export interface AnimationDefinition {
    backgroundColor?: Color;

    curve?: any;

    delay?: number;

    duration?: number;

    // Warning: (ae-forgotten-export) The symbol "PercentLength" needs to be exported by the entry point index.d.ts
    height?: PercentLength | string;

    iterations?: number;

    opacity?: number;

    rotate?: number;

    scale?: Pair;

    target?: View;

    // Warning: (ae-forgotten-export) The symbol "Pair" needs to be exported by the entry point index.d.ts
    translate?: Pair;

    width?: PercentLength | string;
}

// @public (undocumented)
export const Application: {
    launchEvent: string;
    displayedEvent: string;
    uncaughtErrorEvent: string;
    discardedErrorEvent: string;
    suspendEvent: string;
    resumeEvent: string;
    exitEvent: string;
    lowMemoryEvent: string;
    orientationChangedEvent: string;
    getMainEntry: typeof getMainEntry;
    getRootView: typeof getRootView;
    setResources: typeof setResources;
    setCssFileName: typeof setCssFileName;
    getCssFileName: typeof getCssFileName;
    loadAppCss: typeof loadAppCss;
    addCss: typeof addCss;
    on: typeof on;
    off: typeof off;
    run: typeof run;
    orientation: typeof orientation;
    getNativeApplication: typeof getNativeApplication;
    hasLaunched: typeof hasLaunched;
    android: import("./application/application").AndroidApplication;
    ios: import("./application/application").iOSApplication;
};

// @public
export interface ApplicationEventData extends EventData {
    android?: any;

    eventName: string;

    ios?: any;

    object: any;
}

// @public (undocumented)
export const ApplicationSettings: {
    clear: typeof clear;
    flush: typeof flush;
    hasKey: typeof hasKey;
    remove: typeof remove;
    setString: typeof setString;
    getString: typeof getString;
    getAllKeys: typeof getAllKeys;
    getBoolean: typeof getBoolean;
    setBoolean: typeof setBoolean;
    getNumber: typeof getNumber;
    setNumber: typeof setNumber;
};

// @public
export interface BackstackEntry {
    // (undocumented)
    entry: NavigationEntry;
    // (undocumented)
    fragment?: any;
    // (undocumented)
    fragmentTag: string;
    // (undocumented)
    frameId?: number;
    // (undocumented)
    navDepth: number;
    // (undocumented)
    recreated?: boolean;
    // (undocumented)
    resolvedPage: Page;
    // (undocumented)
    viewSavedState?: any;
    //@endprivate
}

// @public
export class BottomNavigation extends TabNavigationBase {
    android: any /* android.view.View */;

    ios: any /* UITabBarController */;

    items: Array<TabContentItem>;

    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    on(event: "selectedIndexChanged", callback: (args: SelectedIndexChangedEventData) => void, thisArg?: any);

    selectedIndex: number;

    public static selectedIndexChangedEvent: string;

    tabStrip: TabStrip;
}

// @public (undocumented)
export class Builder {
    static createViewFromEntry(entry: NavigationEntry): View;

    static load(moduleName: string, exports?: any): View;

    static load(options: LoadOptions): View;

    // (undocumented)
    static parse(value: string | Template, exports?: any): View;

    static parseMultipleTemplates(value: string, exports?: any): Array<KeyedTemplate>;
}

// @public
export class Button extends TextBase {
    android: any /* android.widget.Button */;

    ios: any /* UIButton */;

    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    on(event: "tap", callback: (args: EventData) => void, thisArg?: any);

    public static tapEvent: string;

    textWrap: boolean;
}

// @public
export interface ChangedData<T> extends EventData {
    action: string;

    addedCount: number;

    index: number;

    removed: Array<T>;
}

// @public
export class ChangeType {
    // (undocumented)
    static Add: string;
    // (undocumented)
    static Delete: string;
    // (undocumented)
    static Splice: string;
    // (undocumented)
    static Update: string;
}

// @public
export class Color {
    constructor(knownColor: string);
    constructor(hex: string);
    constructor(argb: number);
    constructor(alpha: number, red: number, green: number, blue: number);
    public a: number;
    android: number;
    public argb: number;
    public b: number;
    public equals(value: Color): boolean;
    public static equals(value1: Color, value2: Color): boolean;
    public g: number;
    public hex: string;
    ios: any /* UIColor */;
    public static isValid(value: any): boolean;
    public name: string;
    public r: number;
}

// @public (undocumented)
export interface CommonLayoutParams {
    // (undocumented)
    bottomMargin: number;
    // (undocumented)
    bottomMarginPercent: number;
    // (undocumented)
    height: number;
    // (undocumented)
    heightPercent: number;
    // Warning: (ae-forgotten-export) The symbol "HorizontalAlignment" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    horizontalAlignment: HorizontalAlignment;
    // (undocumented)
    leftMargin: number;
    // (undocumented)
    leftMarginPercent: number;
    // (undocumented)
    rightMargin: number;
    // (undocumented)
    rightMarginPercent: number;
    // (undocumented)
    topMargin: number;
    // (undocumented)
    topMarginPercent: number;
    // Warning: (ae-forgotten-export) The symbol "VerticalAlignment" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    verticalAlignment: VerticalAlignment;
    // (undocumented)
    width: number;
    // (undocumented)
    widthPercent: number;
}

// @public (undocumented)
export const Connectivity: {
    connectionType: typeof connectionType;
    getConnectionType: typeof getConnectionType;
    startMonitoring: typeof startMonitoring;
    stopMonitoring: typeof stopMonitoring;
};

// Warning: (ae-forgotten-export) The symbol "AddChildFromBuilder" needs to be exported by the entry point index.d.ts
//
// @public
export class ContentView extends View implements AddChildFromBuilder {
    // (undocumented)
    _addChildFromBuilder(name: string, value: any): void;

    //@private
    content: View;

    //@private
    // (undocumented)
    layoutView: View;

    //@private
    _onContentChanged(oldView: View, newView: View);
}

// @public
export interface CreateViewEventData extends EventData {
    context?: any;

    view: any;
}

// @public
export interface CssChangedEventData extends EventData {
    // (undocumented)
    cssFile?: string;
    // (undocumented)
    cssText?: string;
}

// @public
export class DatePicker extends View {
    android: any /* android.widget.DatePicker */;

    date: Date;

    day: number;

    ios: any /* UIDatePicker */;

    maxDate: Date;

    minDate: Date;

    month: number;

    year: number;
}

// @public (undocumented)
export class DefaultErrorHandler implements ErrorHandler {
    // (undocumented)
    handlerError(error);
}

// Warning: (ae-forgotten-export) The symbol "Device" needs to be exported by the entry point index.d.ts
//
// @public
export const Device: Device_2;

// @public
export interface DiscardedErrorEventData extends ApplicationEventData {
    // (undocumented)
    error: NativeScriptError;
}

// @public
export class DockLayout extends LayoutBase {
    // Warning: (ae-forgotten-export) The symbol "Dock" needs to be exported by the entry point index.d.ts
    static getDock(view: View): Dock;

    static setDock(view: View, value: Dock): void;

    stretchLastChild: boolean;
}

// @public
export interface DownloadedData extends EventData {
    image: ImageSource;
    key: string;
}

// @public
export interface DownloadError extends EventData {
    error: Error;
    key: string;
}

// @public
export interface DownloadRequest {
    completed?: (image: any, key: string) => void;
    error?: (key: string) => void;
    key: string;
    url: string;
}

// @public
export class EditableTextBase extends TextBase {
    // Warning: (ae-forgotten-export) The symbol "AutocapitalizationType" needs to be exported by the entry point index.d.ts
    autocapitalizationType: AutocapitalizationType;
    autocorrect: boolean;
    // (undocumented)
    public static blurEvent: string;
    dismissSoftInput(): void;
    editable: boolean;
    // (undocumented)
    public static focusEvent: string;
    hint: string;
    // Warning: (ae-forgotten-export) The symbol "KeyboardType" needs to be exported by the entry point index.d.ts
    keyboardType: KeyboardType;
    maxLength: number;
    // Warning: (ae-forgotten-export) The symbol "ReturnKeyType" needs to be exported by the entry point index.d.ts
    returnKeyType: ReturnKeyType;
    // (undocumented)
    public _setInputType(inputType: number): void;
    // (undocumented)
    public static textChangeEvent: string;
    // Warning: (ae-forgotten-export) The symbol "UpdateTextTrigger" needs to be exported by the entry point index.d.ts
    updateTextTrigger: UpdateTextTrigger;
    //@endprivate
}

// @public
export module encoding {
    const ISO_8859_1: any;

    const US_ASCII: any;

    const UTF_16: any;

    const UTF_16BE: any;

    const UTF_16LE: any;

    const UTF_8: any;
}

// @public
export interface ErrorHandler {
    // (undocumented)
    handlerError(error: Error);
}

// @public
export interface EventData {
    eventName: string;
    object: Observable;
}

// @public
export class File extends FileSystemEntity {
    static exists(path: string): boolean;

    extension: string;

    static fromPath(path: string): File;

    isLocked: boolean;

    read(): Promise<any>;

    readSync(onError?: (error: any) => any): any;

    readText(encoding?: string): Promise<string>;

    readTextSync(onError?: (error: any) => any, encoding?: string): string;

    size: number;

    write(content: any): Promise<void>;

    writeSync(content: any, onError?: (error: any) => any): void;

    writeText(content: string, encoding?: string): Promise<any>;

    writeTextSync(content: string, onError?: (error: any) => any, encoding?: string): void;
}

// @public
export class FileSystemEntity {
    lastModified: Date;

    name: string;

    parent: Folder;

    path: string;

    remove(): Promise<any>;

    removeSync(onError?: (error: any) => any): void;

    rename(newName: string): Promise<any>;

    renameSync(newName: string, onError?: (error: any) => any): void;
}

// @public (undocumented)
export class FlexboxLayout extends LayoutBase {
    // Warning: (ae-forgotten-export) The symbol "AlignContent" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public alignContent: AlignContent;
    // Warning: (ae-forgotten-export) The symbol "AlignItems" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public alignItems: AlignItems;
    // Warning: (ae-forgotten-export) The symbol "FlexDirection" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public flexDirection: FlexDirection;
    // Warning: (ae-forgotten-export) The symbol "FlexWrap" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public flexWrap: FlexWrap;
    // (undocumented)
    public static getAlignSelf(view: View): AlignSelf;
    // (undocumented)
    public static getFlexGrow(view: View);
    // (undocumented)
    public static getFlexShrink(view: View): number;
    // (undocumented)
    public static getFlexWrapBefore(view: View): boolean;
    // (undocumented)
    public static getOrder(view: View): number;
    // Warning: (ae-forgotten-export) The symbol "JustifyContent" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public justifyContent: JustifyContent;
    // Warning: (ae-forgotten-export) The symbol "AlignSelf" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public static setAlignSelf(view: View, align: AlignSelf);
    // (undocumented)
    public static setFlexGrow(view: View, grow: number);
    // (undocumented)
    public static setFlexShrink(view: View, shrink: number);
    // (undocumented)
    public static setFlexWrapBefore(view: View, wrap: boolean);
    // (undocumented)
    public static setOrder(view: View, order: number);
}

// @public
export class Folder extends FileSystemEntity {
    clear(): Promise<any>;

    clearSync(onError?: (error: any) => void): void;

    contains(name: string): boolean;

    eachEntity(onEntity: (entity: FileSystemEntity) => boolean);

    static exists(path: string): boolean;

    static fromPath(path: string): Folder;

    getEntities(): Promise<Array<FileSystemEntity>>;

    getEntitiesSync(onError?: (error: any) => any): Array<FileSystemEntity>;

    getFile(name: string): File;

    getFolder(name: string): Folder;

    isKnown: boolean;
}

// @public
export class FormattedString extends ViewBase {

    public backgroundColor: Color;

    public color: Color;

    public fontFamily: string;

    public fontSize: number;

    // Warning: (ae-forgotten-export) The symbol "FontStyle" needs to be exported by the entry point index.d.ts
    public fontStyle: FontStyle;

    // Warning: (ae-forgotten-export) The symbol "FontWeight" needs to be exported by the entry point index.d.ts
    public fontWeight: FontWeight;

    public spans: ObservableArray<Span>;

    // Warning: (ae-forgotten-export) The symbol "TextDecoration" needs to be exported by the entry point index.d.ts
    public textDecoration: TextDecoration;

    public toString(): string;
}

// @public
export class Frame extends View {
    public actionBarVisibility: "auto" | "never" | "always";

    // Warning: (ae-forgotten-export) The symbol "AndroidFrame" needs to be exported by the entry point index.d.ts
    android: AndroidFrame;

    animated: boolean;

    backStack: Array<BackstackEntry>;

    canGoBack(): boolean;

    currentEntry: NavigationEntry;

    // (undocumented)
    _currentEntry: BackstackEntry;

    currentPage: Page;

    static defaultAnimatedNavigation: boolean;

    static defaultTransition: NavigationTransition;

    // (undocumented)
    _executingContext: NavigationContext;

    // (undocumented)
    _findEntryForTag(fragmentTag: string): BackstackEntry;

    static getFrameById(id: string): Frame;

    // (undocumented)
    _getIsAnimatedNavigation(entry: NavigationEntry): boolean;

    // (undocumented)
    _getNavBarVisible(page: Page): boolean;

    // (undocumented)
    _getNavigationTransition(entry: NavigationEntry): NavigationTransition;

    static goBack();

    goBack(to?: BackstackEntry);

    // Warning: (ae-forgotten-export) The symbol "iOSFrame" needs to be exported by the entry point index.d.ts
    ios: iOSFrame;

    // (undocumented)
    isCurrent(entry: BackstackEntry): boolean;

    navigate(pageModuleName: string);

    navigate(create: () => Page);

    navigate(entry: NavigationEntry);

    // (undocumented)
    navigationBarHeight: number;

    // (undocumented)
    navigationQueueIsEmpty(): boolean;

    on(eventNames: string, callback: (args: EventData) => void, thisArg?: any);

    // (undocumented)
    public performNavigation(navigationContext: NavigationContext): void;

    // (undocumented)
    _processNavigationQueue(page: Page);

    // (undocumented)
    _pushInFrameStack();

    // (undocumented)
    _pushInFrameStackRecursive();

    // (undocumented)
    static reloadPage(context?: ModuleContext): void;

    // (undocumented)
    _removeFromFrameStack();

    // Warning: (ae-forgotten-export) The symbol "NavigationType" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    setCurrent(entry: BackstackEntry, navigationType: NavigationType): void;

    // (undocumented)
    static _stack(): Array<Frame>;

    static topmost(): Frame;

    transition: NavigationTransition;

    // (undocumented)
    _updateActionBar(page?: Page, disableNavBarAnimation?: boolean);

    // (undocumented)
    _updateBackstack(entry: BackstackEntry, navigationType: NavigationType): void;
}

// @public
export interface GestureEventData extends EventData {
    android: any
    ios: any /* UIGestureRecognizer */;
    type: GestureTypes;
    view: View;
}

// @public
export interface GestureEventDataWithState extends GestureEventData {
    // (undocumented)
    state: number;
}

// @public
export class GesturesObserver {
    constructor(target: View, callback: (args: GestureEventData) => void, context: any);

    androidOnTouchEvent: (motionEvent: any /* android.view.MotionEvent */) => void;

    callback: (args: GestureEventData) => void;

    context: any;

    disconnect();

    observe(type: GestureTypes);

    type: GestureTypes;
}

// @public
export enum GestureStateTypes {
    began,
    cancelled,
    changed,
    ended
}

// @public
export enum GestureTypes {
    doubleTap,
    longPress,
    pan,
    pinch,
    rotation,
    swipe,
    tap,
    touch
}

// @public
export class GridLayout extends LayoutBase {

    public addChildAtCell(view: View, row: number, column: number, rowSpan?: number, columnSpan?: number): void;

    // Warning: (ae-forgotten-export) The symbol "ItemSpec" needs to be exported by the entry point index.d.ts
    public addColumn(itemSpec: ItemSpec): void;

    public addRow(itemSpec: ItemSpec): void;

    static getColumn(view: View): number;

    public getColumns(): Array<ItemSpec>;

    static getColumnSpan(view: View): number;

    static getRow(view: View): number;

    public getRows(): Array<ItemSpec>;

    static getRowSpan(view: View): number;

    // (undocumented)
    public _onColumnAdded(itemSpec: ItemSpec): void;

    // (undocumented)
    public _onColumnRemoved(itemSpec: ItemSpec, index: number): void;

    // (undocumented)
    public _onRowAdded(itemSpec: ItemSpec): void;

    // (undocumented)
    public _onRowRemoved(itemSpec: ItemSpec, index: number): void;

    public removeColumn(itemSpec: ItemSpec): void;

    public removeColumns(): void;

    public removeRow(itemSpec: ItemSpec): void;

    public removeRows(): void;

    static setColumn(view: View, value: number): void;

    static setColumnSpan(view: View, value: number): void;

    static setRow(view: View, value: number): void;

    static setRowSpan(view: View, value: number): void;
    //@endprivate
}

// @public (undocumented)
export type GridUnitType = "pixel" | "star" | "auto";

// @public (undocumented)
export namespace GridUnitType {
    const // (undocumented)
    PIXEL: "pixel";
    const // (undocumented)
    STAR: "star";
    const // (undocumented)
    AUTO: "auto";
    // (undocumented)
    export function isValid(value: any): boolean;
    // (undocumented)
    export function parse(value: string): GridUnitType;
}

// @public (undocumented)
export type Headers = { [key: string]: string | string[] };

// @public
export class HtmlView extends View {
    android: any /* android.widget.TextView */;

    html: string;

    ios: any /* UITextView */;
}

// @public (undocumented)
export const Http: {
    getFile: typeof getFile;
    getImage: typeof getImage;
    getJSON: typeof getJSON;
    getString: typeof getString_2;
    request: typeof request;
};

// @public
export interface HttpContent {
  raw: any;

  toFile: (destinationFilePath?: string) => File;

  toImage: () => Promise<ImageSource>;

  toJSON: (encoding?: HttpResponseEncoding) => any;

  toString: (encoding?: HttpResponseEncoding) => string;
}

// @public
export interface HttpRequestOptions {
  content?: string | FormData;

  dontFollowRedirects?: boolean;

  headers?: any;

  method: string;

  timeout?: number;

  url: string;
}

// @public
export interface HttpResponse {
  content?: HttpContent;

  headers: Headers;

  statusCode: number;
}

// @public (undocumented)
export enum HttpResponseEncoding {
  // (undocumented)
  GBK,
  // (undocumented)
  UTF8
}

// @public
export class Image extends View {
    android: any /* android.widget.ImageView */;

    decodeHeight: Length;

    decodeWidth: Length;

    imageSource: ImageSource;

    ios: any /* UIImageView */;

    readonly isLoading: boolean;

    loadMode: "sync" | "async";

    src: any;

    // Warning: (ae-forgotten-export) The symbol "Stretch" needs to be exported by the entry point index.d.ts
    stretch: Stretch;

    tintColor: Color;
}

// @public (undocumented)
export class ImageAsset extends Observable {
    constructor(asset: any);
    // (undocumented)
    android: any;
    // (undocumented)
    getImageAsync(callback: (image: any, error: any) => void);
    // (undocumented)
    ios: any;
    // (undocumented)
    nativeImage: any;
    // (undocumented)
    options: ImageAssetOptions;
}

// @public (undocumented)
export interface ImageAssetOptions {
    // (undocumented)
    autoScaleFactor?: boolean;
    // (undocumented)
    height?: number;
    // (undocumented)
    keepAspectRatio?: boolean;
    // (undocumented)
    width?: number;
}

// @public
export class ImageCache extends Observable {
    clear(): void;
    disableDownload(): void;
    // (undocumented)
    _downloadCore(request: DownloadRequest);
    public static downloadedEvent: string;
    public static downloadErrorEvent: string;
    enableDownload(): void;
    enqueue(request: DownloadRequest);
    get(key: string): any;
    maxRequests: number;
    on(eventNames: string, callback: (args: EventData) => void, thisArg?: any);
    on(event: "downloaded", callback: (args: DownloadedData) => void, thisArg?: any);
    on(event: "downloadError", callback: (args: DownloadError) => void, thisArg?: any);
    // (undocumented)
    _onDownloadCompleted(key: string, image: any);
    // (undocumented)
    _onDownloadError(key: string, err: Error);
    placeholder: ImageSource;
    push(request: DownloadRequest);
    remove(key: string): void;
    set(key: string, image: any): void;
    //@endprivate
}

// @public
export class ImageSource {
    constructor(nativeSource?: any);

    android: any /* android.graphics.Bitmap */;

    static fromAsset(asset: ImageAsset): Promise<ImageSource>;

    // @deprecated (undocumented)
    fromAsset(asset: ImageAsset): Promise<ImageSource>;

    static fromBase64(source: string): Promise<ImageSource>;

    // @deprecated (undocumented)
    fromBase64(source: string): Promise<boolean>;

    static fromBase64Sync(source: string): ImageSource;

    static fromData(data: any): Promise<ImageSource>;

    // @deprecated (undocumented)
    fromData(data: any): Promise<boolean>;

    static fromDataSync(data: any): ImageSource;

    static fromFile(path: string): Promise<ImageSource>;

    // @deprecated (undocumented)
    fromFile(path: string): Promise<boolean>;

    static fromFileOrResourceSync(path: string): ImageSource;

    static fromFileSync(path: string): ImageSource;

    // Warning: (ae-forgotten-export) The symbol "Font" needs to be exported by the entry point index.d.ts
    static fromFontIconCodeSync(source: string, font: Font, color: Color): ImageSource;

    static fromResource(name: string): Promise<ImageSource>;

    // @deprecated (undocumented)
    fromResource(name: string): Promise<boolean>;

    static fromResourceSync(name: string): ImageSource;

    static fromUrl(url: string): Promise<ImageSource>;

    height: number;

    ios: any /* UIImage */;

    // @deprecated (undocumented)
    loadFromBase64(source: string): boolean;

    // @deprecated (undocumented)
    loadFromData(data: any): boolean;

    // @deprecated (undocumented)
    loadFromFile(path: string): boolean;

    // @deprecated (undocumented)
    loadFromFontIconCode(source: string, font: Font, color: Color): boolean;

    // @deprecated (undocumented)
    loadFromResource(name: string): boolean;

    rotationAngle: number;

    saveToFile(path: string, format: "png" | "jpeg" | "jpg", quality?: number): boolean;

    setNativeSource(nativeSource: any): void;

    toBase64String(format: "png" | "jpeg" | "jpg", quality?: number): string;

    width: number;
}

// @public
export type InstrumentationMode = "counters" | "timeline" | "lifecycle";

// @public
export class iOSApplication {
    /* tslint:enable */
    addNotificationObserver(notificationName: string, onReceiveCallback: (notification: any /* NSNotification */) => void): any;

    /* tslint:enable */
    delegate: any /* typeof UIApplicationDelegate */;

    /* tslint:enable */
    nativeApp: any /* UIApplication */;

    /* tslint:enable */
    orientation: "portrait" | "landscape" | "unknown";

    /* tslint:enable */
    removeNotificationObserver(observer: any, notificationName: string): void;

    /* tslint:enable */
    rootController: any /* UIViewController */;

    /* tslint:enable */
    systemAppearance: "dark" | "light" | null;

    /* tslint:enable */
    window: any /* UIWindow */;
}

// @public
export const isAndroid: boolean;

// @public
export const isIOS: boolean;

// @public
export interface ItemEventData extends EventData {
    android: any /* android.view.ViewGroup */;

    index: number;

    ios: any /* UITableViewCell */;

    view: View;
}

// @public (undocumented)
export interface ItemsSource {
    // (undocumented)
    getItem(index: number): any;
    // (undocumented)
    length: number;
}

// @public
export interface KeyedTemplate {
    createView: Template;

    key: string;
}

// @public
export module knownFolders {
    export function currentApp(): Folder;

    export function documents(): Folder;

    export module ios {
        export function desktop(): Folder;

        export function developer(): Folder;

        export function downloads(): Folder;

        export function library(): Folder;

        export function movies(): Folder;

        export function music(): Folder;

        export function pictures(): Folder;

        export function sharedPublic(): Folder;
    }

    export function temp(): Folder;
}

// @public
export class Label extends TextBase {
    android: any /* android.widget.TextView */;

    ios: any /* UILabel */;

    textWrap: boolean;
}

// @public
export interface LaunchEventData extends ApplicationEventData {
    root?: View;

    // (undocumented)
    savedInstanceState?: any /* android.os.Bundle */;
}

// Warning: (ae-forgotten-export) The symbol "CustomLayoutView" needs to be exported by the entry point index.d.ts
//
// @public
export class LayoutBase extends CustomLayoutView {
    addChild(view: View): void;

    clipToBounds: boolean;

    eachLayoutChild(callback: (child: View, isLast: boolean) => void): void;

    getChildAt(index: number): View;

    getChildIndex(child: View): number;

    getChildrenCount(): number;

    insertChild(child: View, atIndex: number): void;

    isPassThroughParentEnabled: boolean;

    padding: string | Length;

    paddingBottom: Length;

    paddingLeft: Length;

    paddingRight: Length;

    paddingTop: Length;

    _registerLayoutChild(child: View): void;

    removeChild(view: View): void;

    removeChildren(): void;

    _unregisterLayoutChild(child: View): void;
}

// @public
export class ListPicker extends View {
    android: any /* android.widget.NumberPicker */;

    ios: any /* UIPickerView */;

    items: any;

    selectedIndex: number;
}

// @public
export class ListView extends View {
    android: any /* android.widget.ListView */;
    ios: any /* UITableView */;
    iosEstimatedRowHeight: Length;
    isItemAtIndexVisible(index: number): boolean;
    itemIdGenerator: (item: any, index: number, items: any) => number;
    public static itemLoadingEvent: string;
    items: any[] | ItemsSource;
    public static itemTapEvent: string;
    itemTemplate: string | Template;
    itemTemplates: string | Array<KeyedTemplate>;
    itemTemplateSelector: string | ((item: any, index: number, items: any) => string);
    public static loadMoreItemsEvent: string;
    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);
    on(event: "itemLoading", callback: (args: ItemEventData) => void, thisArg?: any);
    on(event: "itemTap", callback: (args: ItemEventData) => void, thisArg?: any);
    on(event: "loadMoreItems", callback: (args: EventData) => void, thisArg?: any);
    refresh();
    rowHeight: Length;
    scrollToIndex(index: number);
    scrollToIndexAnimated(index: number);
    separatorColor: Color;
}

// @public (undocumented)
export interface LoadAppCSSEventData extends EventData {
    // (undocumented)
    cssFile: string;
}

// @public (undocumented)
export interface LoadOptions {
    // (undocumented)
    attributes?: any;
    // (undocumented)
    exports?: any;
    // (undocumented)
    name: string;
    // (undocumented)
    page?: Page;
    // (undocumented)
    path: string;
}

// @public
export interface NavigatedData extends EventData {
    context: any;

    isBackNavigation: boolean;
}

// @public
export class NavigationButton extends ActionItem {
    //@private
    // (undocumented)
    _navigationItem?: any
    //@endprivate
}

// @public
export interface NavigationContext {
    // (undocumented)
    entry: BackstackEntry;
    // (undocumented)
    isBackNavigation: boolean;
    // (undocumented)
    navigationType: NavigationType;
}

// @public
export interface NavigationEntry extends ViewEntry {
    animated?: boolean;

    backstackVisible?: boolean;

    bindingContext?: any;

    clearHistory?: boolean;

    context?: any;

    transition?: NavigationTransition;

    transitionAndroid?: NavigationTransition;

    transitioniOS?: NavigationTransition;
}

// @public
export interface NavigationTransition {
    curve?: any;

    duration?: number;

    instance?: Transition;

    name?: string;
}

// @public
export class Observable {

    constructor();

    addEventListener(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    _createPropertyChangeData(name: string, value: any, oldValue?: any): PropertyChangeData;

    // (undocumented)
    _emit(eventNames: string);

    get(name: string): any;

    hasListeners(eventName: string): boolean;

    public _isViewBase: boolean;

    notify<T extends EventData>(data: T): void;

    notifyPropertyChange(propertyName: string, value: any, oldValue?: any): void;

    off(eventNames: string, callback?: any, thisArg?: any);

    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    on(event: "propertyChange", callback: (data: EventData) => void, thisArg?: any);

    once(event: string, callback: (data: EventData) => void, thisArg?: any);

    public static propertyChangeEvent: string;

    removeEventListener(eventNames: string, callback?: any, thisArg?: any);

    set(name: string, value: any): void;
    //@endprivate
}

// @public
export class ObservableArray<T> extends Observable {
    constructor(arrayLength?: number);

    constructor(items: T[]);

    constructor(...items: T[]);

    public static changeEvent: string;

    concat<U extends T[]>(...items: U[]): T[];

    concat(...items: T[]): T[];

    every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;

    filter(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];

    forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;

    getItem(index: number): T;

    indexOf(searchElement: T, fromIndex?: number): number;

    join(separator?: string): string;

    lastIndexOf(searchElement: T, fromIndex?: number): number;

    length: number;

    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];

    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    on(event: "change", callback: (args: ChangedData<T>) => void, thisArg?: any);

    pop(): T;

    push(items: T[]): number;

    push(...items: T[]): number;

    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;

    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;

    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;

    reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;

    reverse(): T[];

    setItem(index: number, value: T): void;

    shift(): T;

    slice(start?: number, end?: number): T[];

    some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;

    sort(compareFn?: (a: T, b: T) => number): T[];

    splice(start: number): T[];

    splice(start: number, deleteCount: number, ...items: T[]): T[];

    // (undocumented)
    toLocaleString(): string;

    toString(): string;

    unshift(...items: T[]): number;
}

// @public
export interface OrientationChangedEventData extends ApplicationEventData {
    newValue: "portrait" | "landscape" | "unknown";
}

// @public
export class Page extends ContentView {
    public actionBar: ActionBar;

    public actionBarHidden: boolean;

    public androidStatusBarBackground: Color;

    public backgroundSpanUnderStatusBar: boolean;

    public enableSwipeBackNavigation: boolean;

    public frame: Frame;

    // (undocumented)
    _frame: Frame;

    // Warning: (ae-forgotten-export) The symbol "KeyframeAnimationInfo" needs to be exported by the entry point index.d.ts
    public getKeyframeAnimationWithName(animationName: string): KeyframeAnimationInfo;

    // (undocumented)
    hasActionBar: boolean;

    public static navigatedFromEvent: string;

    public static navigatedToEvent: string;

    public static navigatingFromEvent: string;

    public static navigatingToEvent: string;

    public navigationContext: any;

    public on(eventNames: string, callback: (data: EventData) => void, thisArg?: any): void;

    public on(event: "navigatingTo", callback: (args: NavigatedData) => void, thisArg?: any): void;

    public on(event: "navigatedTo", callback: (args: NavigatedData) => void, thisArg?: any): void;

    public on(event: "navigatingFrom", callback: (args: NavigatedData) => void, thisArg?: any): void;

    public on(event: "navigatedFrom", callback: (args: NavigatedData) => void, thisArg?: any): void;

    public onNavigatedFrom(isBackNavigation: boolean): void;

    public onNavigatedTo(isBackNavigation: boolean): void;

    public onNavigatingFrom(isBackNavigation: boolean): void;

    public onNavigatingTo(context: any, isBackNavigation: boolean, bindingContext?: any): void;

    public statusBarStyle: "light" | "dark";
    //@endprivate
}

// @public
export interface PanGestureEventData extends GestureEventDataWithState {
    // (undocumented)
    deltaX: number;
    // (undocumented)
    deltaY: number;
}

// @public
export interface ParserEvent {

    attributes?: Object;

    data?: string;

    elementName?: string;

    eventType: string;

    namespace?: string;

    // Warning: (ae-forgotten-export) The symbol "Position" needs to be exported by the entry point index.d.ts
    position: Position;

    prefix?: string;

    toString(): string;
}

// @public
export class ParserEventType {

    static CDATA: string;

    static Comment: string;

    static EndElement: string;

    static StartElement: string;

    static Text: string;
}

// @public
export module path {
    export function join(...paths: string[]): string;

    export function normalize(path: string): string;

    const separator: string;
}

// @public
export interface PinchGestureEventData extends GestureEventDataWithState {
    // (undocumented)
    getFocusX(): number;

    // (undocumented)
    getFocusY(): number;

    // (undocumented)
    scale: number;
}

// @public
export class Placeholder extends View {
    public static creatingViewEvent: string;

    on(eventNames: string, callback: (args: EventData) => void);

    on(event: "creatingView", callback: (args: CreateViewEventData) => void);
}

// @public (undocumented)
export const Profiling: {
    enable: typeof enable;
    disable: typeof disable;
    time: typeof time;
    uptime: typeof uptime;
    start: typeof start;
    stop: typeof stop;
    isRunning: typeof isRunning;
    dumpProfiles: typeof dumpProfiles;
    resetProfiles: typeof resetProfiles;
    profile: typeof profile;
    startCPUProfile: typeof startCPUProfile;
    stopCPUProfile: typeof stopCPUProfile;
};

// @public
export class Progress extends View {
    android: any /* android.widget.ProgressBar */;

    ios: any /* UIProgressView */;

    maxValue: number;

    value: number;
}

// @public
export interface PropertyChangeData extends EventData {
    oldValue?: any;
    propertyName: string;
    value: any;
}

// @public (undocumented)
export class ProxyViewContainer extends LayoutBase {
}

// @public
export class Repeater extends CustomLayoutView {
    // Warning: (ae-forgotten-export) The symbol "ItemsSource" needs to be exported by the entry point index.d.ts
    items: any[] | ItemsSource_2;

    itemsLayout: LayoutBase;

    itemTemplate: string | Template;

    refresh();
}

// @public
export interface RotationGestureEventData extends GestureEventDataWithState {
    // (undocumented)
    rotation: number;
}

// @public
export module Screen {
    const // Warning: (ae-forgotten-export) The symbol "ScreenMetrics" needs to be exported by the entry point index.d.ts
    mainScreen: ScreenMetrics;
}

// @public (undocumented)
export interface ScrollEventData extends EventData {
    // (undocumented)
    scrollX: number;
    // (undocumented)
    scrollY: number;
}

// @public
export class ScrollView extends ContentView {
    horizontalOffset: number;

    isScrollEnabled: boolean;

    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    on(event: "scroll", callback: (args: ScrollEventData) => void, thisArg?: any);

    // (undocumented)
    _onOrientationChanged();

    // Warning: (ae-forgotten-export) The symbol "Orientation" needs to be exported by the entry point index.d.ts
    orientation: Orientation;

    scrollableHeight: number;

    scrollableWidth: number;

    scrollBarIndicatorVisible: boolean;

    public static scrollEvent: string;

    scrollToHorizontalOffset(value: number, animated: boolean);

    scrollToVerticalOffset(value: number, animated: boolean);

    verticalOffset: number;
}

// @public
export class SearchBar extends View {
    android: any /* android.widget.SearchView */;

    public static clearEvent: string;

    dismissSoftInput(): void;

    hint: string;

    ios: any /* UISearchBar */;

    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    on(event: "submit", callback: (args: EventData) => void, thisArg?: any);

    on(event: "close", callback: (args: EventData) => void, thisArg?: any);

    public static submitEvent: string;

    text: string;

    textFieldBackgroundColor: Color;

    textFieldHintColor: Color;
}

// Warning: (ae-forgotten-export) The symbol "AddArrayFromBuilder" needs to be exported by the entry point index.d.ts
//
// @public
export class SegmentedBar extends View implements AddChildFromBuilder, AddArrayFromBuilder {
    // (undocumented)
    public _addArrayFromBuilder(name: string, value: Array<any>): void;

    public _addChildFromBuilder(name: string, value: any): void;

    items: Array<SegmentedBarItem>;

    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    // Warning: (ae-forgotten-export) The symbol "SelectedIndexChangedEventData" needs to be exported by the entry point index.d.ts
    on(event: "selectedIndexChanged", callback: (args: SelectedIndexChangedEventData_3) => void, thisArg?: any);

    selectedBackgroundColor: Color;

    selectedIndex: number;

    public static selectedIndexChangedEvent: string;
}

// @public
export class SegmentedBarItem extends ViewBase {
    public title: string;
}

// @public
export interface SelectedIndexChangedEventData extends EventData {
    newIndex: number;

    oldIndex: number;
}

// @public (undocumented)
export interface ShowModalOptions {
    // (undocumented)
    android?: {
        cancelable?: boolean
    }

    animated?: boolean;

    cancelable?: boolean

    closeCallback: Function;

    context: any;

    fullscreen?: boolean;

    ios?: {
        presentationStyle?: any; /* UIModalPresentationStyle */
        width?: number;
        height?: number;
    }

    stretched?: boolean;
}

// @public
export interface ShownModallyData extends EventData {
    closeCallback?: Function;

    context?: any;
}

// @public
export class Slider extends View {
    android: any /* android.widget.SeekBar */;

    ios: any /* UISlider */;

    maxValue: number;

    minValue: number;

    value: number;
}

// @public
export class Span extends ViewBase {
    public backgroundColor: Color;

    public color: Color;

    public fontFamily: string;

    public fontSize: number;

    public fontStyle: FontStyle;

    public fontWeight: FontWeight;

    // (undocumented)
    _setTextInternal(value: string): void;

    public text: string;

    public textDecoration: TextDecoration;
    //@endprivate
}

// @public
export class StackLayout extends LayoutBase {
    // Warning: (ae-forgotten-export) The symbol "Orientation" needs to be exported by the entry point index.d.ts
    orientation: Orientation_2;
}

// @public (undocumented)
export class Style extends Observable {
    constructor(ownerView: ViewBase | WeakRef<ViewBase>);
    // (undocumented)
    public alignContent: AlignContent;
    // (undocumented)
    public alignItems: AlignItems;
    // (undocumented)
    public alignSelf: AlignSelf;
    public androidContentInset: string | Length;
    public androidContentInsetLeft: Length;
    public androidContentInsetRight: Length;
    // (undocumented)
    public androidDynamicElevationOffset: number;
    // (undocumented)
    public androidElevation: number;
    // (undocumented)
    public androidSelectedTabHighlightColor: Color;
    // (undocumented)
    public androidStatusBarBackground: Color;
    // (undocumented)
    public background: string;
    // (undocumented)
    public backgroundColor: Color;
    // Warning: (ae-forgotten-export) The symbol "LinearGradient" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public backgroundImage: string | LinearGradient;
    // Warning: (ae-forgotten-export) The symbol "Background" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public backgroundInternal: Background;
    // (undocumented)
    public backgroundPosition: string;
    // Warning: (ae-forgotten-export) The symbol "BackgroundRepeat" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public backgroundRepeat: BackgroundRepeat;
    // (undocumented)
    public backgroundSize: string;
    // (undocumented)
    public borderBottomColor: Color;
    // (undocumented)
    public borderBottomLeftRadius: Length;
    // (undocumented)
    public borderBottomRightRadius: Length;
    // (undocumented)
    public borderBottomWidth: Length;
    // (undocumented)
    public borderColor: string | Color;
    // (undocumented)
    public borderLeftColor: Color;
    // (undocumented)
    public borderLeftWidth: Length;
    // (undocumented)
    public borderRadius: string | Length;
    // (undocumented)
    public borderRightColor: Color;
    // (undocumented)
    public borderRightWidth: Length;
    // (undocumented)
    public borderTopColor: Color;
    // (undocumented)
    public borderTopLeftRadius: Length;
    // (undocumented)
    public borderTopRightRadius: Length;
    // (undocumented)
    public borderTopWidth: Length;
    // (undocumented)
    public borderWidth: string | Length;
    // (undocumented)
    public clipPath: string;
    // (undocumented)
    public color: Color;
    // (undocumented)
    public flexDirection: FlexDirection;
    // Warning: (ae-forgotten-export) The symbol "FlexGrow" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public flexGrow: FlexGrow;
    // Warning: (ae-forgotten-export) The symbol "FlexShrink" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public flexShrink: FlexShrink;
    // (undocumented)
    public flexWrap: FlexWrap;
    // Warning: (ae-forgotten-export) The symbol "FlexWrapBefore" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public flexWrapBefore: FlexWrapBefore;
    // (undocumented)
    public font: string;
    // (undocumented)
    public fontFamily: string;
    // (undocumented)
    public fontInternal: Font;
    // (undocumented)
    public fontSize: number;
    // (undocumented)
    public fontStyle: FontStyle;
    // (undocumented)
    public fontWeight: FontWeight;
    public getCssVariable(varName: string): string | null;
    // (undocumented)
    public height: PercentLength;
    // (undocumented)
    public horizontalAlignment: HorizontalAlignment;
    // (undocumented)
    public justifyContent: JustifyContent;
    // (undocumented)
    public letterSpacing: number;
    // (undocumented)
    public lineHeight: number;
    // (undocumented)
    public margin: string | PercentLength;
    // (undocumented)
    public marginBottom: PercentLength;
    // (undocumented)
    public marginLeft: PercentLength;
    // (undocumented)
    public marginRight: PercentLength;
    // (undocumented)
    public marginTop: PercentLength;
    // (undocumented)
    public minHeight: Length;
    // (undocumented)
    public minWidth: Length;
    // (undocumented)
    public opacity: number;
    // Warning: (ae-forgotten-export) The symbol "Order" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public order: Order;
    // (undocumented)
    public padding: string | Length;
    // (undocumented)
    public paddingBottom: Length;
    // (undocumented)
    public paddingLeft: Length;
    // (undocumented)
    public paddingRight: Length;
    // (undocumented)
    public paddingTop: Length;
    // (undocumented)
    public placeholderColor: Color;
    // Warning: (ae-forgotten-export) The symbol "PropertyBagClass" needs to be exported by the entry point index.d.ts
    public readonly PropertyBag: PropertyBagClass;
    public resetScopedCssVariables(): void;
    public resetUnscopedCssVariables(): void;
    // (undocumented)
    public rotate: number;
    // (undocumented)
    public scaleX: number;
    // (undocumented)
    public scaleY: number;
    // (undocumented)
    public selectedBackgroundColor: Color;
    // (undocumented)
    public selectedTabTextColor: Color;
    // (undocumented)
    public separatorColor: Color;
    public setScopedCssVariable(varName: string, value: string): void;
    public setUnscopedCssVariable(varName: string, value: string): void;
    // (undocumented)
    public statusBarStyle: "light" | "dark";
    // (undocumented)
    public tabBackgroundColor: Color;
    // (undocumented)
    public tabTextColor: Color;
    // (undocumented)
    public tabTextFontSize: number;
    // Warning: (ae-forgotten-export) The symbol "TextAlignment" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public textAlignment: TextAlignment;
    // (undocumented)
    public textDecoration: TextDecoration;
    // Warning: (ae-forgotten-export) The symbol "TextTransform" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public textTransform: TextTransform;
    // (undocumented)
    public tintColor: Color;
    // Warning: (ae-forgotten-export) The symbol "dip" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public translateX: dip;
    // (undocumented)
    public translateY: dip;
    // (undocumented)
    public verticalAlignment: VerticalAlignment;
    // @deprecated (undocumented)
    public view: ViewBase;
    // (undocumented)
    public viewRef: WeakRef<ViewBase>;
    // Warning: (ae-forgotten-export) The symbol "Visibility" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public visibility: Visibility;
    // Warning: (ae-forgotten-export) The symbol "WhiteSpace" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public whiteSpace: WhiteSpace;
    // (undocumented)
    public width: PercentLength;
    // (undocumented)
    public zIndex: number;
}

// @public
export enum SwipeDirection {
    down,
    left,
    right,
    up
}

// @public
export interface SwipeGestureEventData extends GestureEventData {
    // (undocumented)
    direction: SwipeDirection;
}

// @public
export class Switch extends View {

    android: any /* android.widget.Switch */;

    checked: boolean;

    // (undocumented)
    public static checkedChangeEvent: string;

    ios: any /* UISwitch */;

    offBackgroundColor: Color;
}

// @public
export class TabContentItem extends ContentView {
    // (undocumented)
    canBeLoaded?: boolean;
}

// @public
export class TabNavigationBase extends View {
    android: any /* android.view.View */;

    getTabBarBackgroundColor(): any

    getTabBarColor(): any

    getTabBarFontInternal(): any

    getTabBarHighlightColor(): any

    getTabBarItemBackgroundColor(tabStripItem: TabStripItem): any

    getTabBarItemColor(tabStripItem: TabStripItem): any

    getTabBarItemFontInternal(tabStripItem: TabStripItem): any

    getTabBarItemFontSize(tabStripItem: TabStripItem): any

    getTabBarItemTextTransform(tabStripItem: TabStripItem): any

    getTabBarTextTransform(): any

    ios: any /* UITabBarController */;

    items: Array<TabContentItem>;

    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    // Warning: (ae-forgotten-export) The symbol "SelectedIndexChangedEventData" needs to be exported by the entry point index.d.ts
    on(event: "selectedIndexChanged", callback: (args: SelectedIndexChangedEventData_2) => void, thisArg?: any);

    onItemsChanged(oldItems: TabContentItem[], newItems: TabContentItem[]): void;

    onSelectedIndexChanged(oldIndex: number, newIndex: number): void;

    selectedIndex: number;

    public static selectedIndexChangedEvent: string;

    setTabBarBackgroundColor(value: any): void

    setTabBarColor(value: any): void

    setTabBarFontInternal(value: any): void

    setTabBarHighlightColor(value: any)

    setTabBarIconColor(tabStripItem: TabStripItem, value: any): void

    setTabBarItemBackgroundColor(tabStripItem: TabStripItem, value: any): void

    setTabBarItemColor(tabStripItem: TabStripItem, value: any): void

    setTabBarItemFontInternal(tabStripItem: TabStripItem, value: any): void

    setTabBarItemFontSize(tabStripItem: TabStripItem, value: any): void

    setTabBarItemTextTransform(tabStripItem: TabStripItem, value: any): void

    setTabBarItemTitle(tabStripItem: TabStripItem, value: any): any

    setTabBarTextTransform(value: any): void

    tabStrip: TabStrip;
}

// @public
export class Tabs extends TabNavigationBase {
    android: any /* android.view.View */;

    ios: any /* UITabBarController */;

    items: Array<TabContentItem>;

    offscreenTabLimit: number;

    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    on(event: "selectedIndexChanged", callback: (args: SelectedIndexChangedEventData_2) => void, thisArg?: any);

    selectedIndex: number;

    public static selectedIndexChangedEvent: string;

    swipeEnabled: boolean;

    tabsPosition: "top" | "bottom";

    tabStrip: TabStrip;
}

// @public
export class TabStrip extends View {

    // (undocumented)
    _hasImage: boolean;

    // (undocumented)
    _hasTitle: boolean;

    highlightColor: Color;

    iosIconRenderingMode: "automatic" | "alwaysOriginal" | "alwaysTemplate";

    isIconSizeFixed: boolean;

    items: Array<TabStripItem>;

    public static itemTapEvent: string;

    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    on(event: "itemTap", callback: (args: TabStripItemEventData) => void, thisArg?: any);
}

// @public
export class TabStripItem extends View {
    iconSource: string;

    image: Image;

    // (undocumented)
    _index: number;

    label: Label;

    on(eventNames: string, callback: (data: EventData) => void);

    on(event: "tap", callback: (args: EventData) => void);

    // (undocumented)
    static selectEvent: string;

    public static tapEvent: string;

    title: string;

    // (undocumented)
    static unselectEvent: string;
}

// @public
export interface TabStripItemEventData extends EventData {
    index: number;
}

// @public
export class TabView extends View {
    android: any /* android.view.View */;

    androidOffscreenTabLimit: number;

    androidSelectedTabHighlightColor: Color;

    androidSwipeEnabled: boolean;

    androidTabsPosition: "top" | "bottom";

    ios: any /* UITabBarController */;

    iosIconRenderingMode: "automatic" | "alwaysOriginal" | "alwaysTemplate";

    items: Array<TabViewItem>;

    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    // Warning: (ae-forgotten-export) The symbol "SelectedIndexChangedEventData" needs to be exported by the entry point index.d.ts
    on(event: "selectedIndexChanged", callback: (args: SelectedIndexChangedEventData_4) => void, thisArg?: any);

    selectedIndex: number;

    public static selectedIndexChangedEvent: string;

    selectedTabTextColor: Color;

    tabBackgroundColor: Color;

    tabTextColor: Color;

    tabTextFontSize: number;
}

// @public
export class TabViewItem extends ViewBase {
    // (undocumented)
    canBeLoaded?: boolean;

    public iconSource: string;

    textTransform: TextTransform;

    public title: string;

    public view: View;
}

// @public
export interface Template {
    (): View;
}

// @public (undocumented)
export interface TemplatedItemsView {
    // (undocumented)
    items: any[] | ItemsSource;
    // (undocumented)
    itemTemplate: string | Template;
    // (undocumented)
    itemTemplates?: string | Array<KeyedTemplate>;
    // (undocumented)
    off(event: "itemLoading", callback: (args: EventData) => void, thisArg?: any);
    // (undocumented)
    on(event: "itemLoading", callback: (args: ItemEventData) => void, thisArg?: any);
    // (undocumented)
    refresh(): void;
}

// @public (undocumented)
export class TextBase extends View implements AddChildFromBuilder {

    _addChildFromBuilder(name: string, value: any): void;

    fontSize: number;

    formattedText: FormattedString;

    // (undocumented)
    _isSingleLine: boolean;

    letterSpacing: number;

    lineHeight: number;

    public readonly nativeTextViewProtected: any;

    padding: string | Length;

    paddingBottom: Length;

    paddingLeft: Length;

    paddingRight: Length;

    paddingTop: Length;

    _requestLayoutOnTextChanged(): void;

    // (undocumented)
    _setNativeText(reset?: boolean): void;

    text: string;

    textAlignment: TextAlignment;

    textDecoration: TextDecoration;

    textTransform: TextTransform;

    whiteSpace: WhiteSpace;
    //@endprivate
}

// @public
export class TextField extends EditableTextBase {
    android: any /* android.widget.EditText */;

    ios: any /* UITextField */;

    // (undocumented)
    public static returnPressEvent: string;

    secure: boolean;
}

// @public
export class TextView extends EditableTextBase {
    android: any /* android.widget.EditText */;

    ios: any /* UITextView */;
}

// @public
export class TimePicker extends View {
    android: any /* android.widget.TimePicker */;

    hour: number;

    ios: any /* UIDatePicker */;

    maxHour: number;

    maxMinute: number;

    minHour: number;

    minMinute: number;

    minute: number;

    minuteInterval: number;

    time: Date;
}

// @public (undocumented)
export interface TimerInfo {
    // (undocumented)
    count: number;
    // (undocumented)
    totalTime: number;
}

// @public
export interface TouchGestureEventData extends GestureEventData {
    action: "up" | "move" | "down" | "cancel";

    // Warning: (ae-forgotten-export) The symbol "Pointer" needs to be exported by the entry point index.d.ts
    getActivePointers(): Array<Pointer>;

    getAllPointers(): Array<Pointer>;

    getPointerCount(): number;

    getX(): number;

    getY(): number;
}

// @public (undocumented)
export const Trace: {
    messageType: typeof messageType;
    categories: typeof categories;
    setCategories: typeof setCategories;
    addCategories: typeof addCategories;
    addWriter: typeof addWriter;
    removeWriter: typeof removeWriter;
    clearWriters: typeof clearWriters;
    setErrorHandler: typeof setErrorHandler;
    write: typeof write;
    error: typeof error;
    enable: typeof enable_2;
    disable: typeof disable_2;
    isEnabled: typeof isEnabled;
};

// @public
export interface TraceWriter {
    // (undocumented)
    write(message: any, category: string, type?: number);
}

// @public (undocumented)
export class Transition {
    constructor(duration: number, nativeCurve: any);
    // (undocumented)
    public animateIOSTransition(containerView: any, fromView: any, toView: any, operation: any, completion: (finished: boolean) => void): void;
    // (undocumented)
    public createAndroidAnimator(transitionType: string): any;
    // (undocumented)
    public getCurve(): any;
    // (undocumented)
    public getDuration(): number;
    // (undocumented)
    public toString(): string;
}

// @public
export interface UnhandledErrorEventData extends ApplicationEventData {
    // (undocumented)
    android?: NativeScriptError;
    // (undocumented)
    error: NativeScriptError;
    // (undocumented)
    ios?: NativeScriptError;
}

// @public (undocumented)
export const Utils: {
    GC: typeof GC;
    isFontIconURI: typeof isFontIconURI;
    isDataURI: typeof isDataURI;
    isFileOrResourcePath: typeof isFileOrResourcePath;
    executeOnMainThread: typeof executeOnMainThread;
    mainThreadify: typeof mainThreadify;
    isMainThread: typeof isMainThread;
    dispatchToMainThread: typeof dispatchToMainThread;
    releaseNativeObject: typeof releaseNativeObject;
    getModuleName: typeof getModuleName;
    openFile: typeof openFile;
    openUrl: typeof openUrl;
    layout: typeof layout;
    android: typeof ad;
    ios: typeof ios;
};

// @public
export abstract class View extends ViewBase {
    addCss(cssString: string): void;
    addCssFile(cssFileName: string): void;
    public android: any;
    androidDynamicElevationOffset: number;
    androidElevation: number;
    public animate(options: AnimationDefinition): AnimationPromise;
    automationText: string;
    background: string;
    backgroundColor: string | Color;
    backgroundImage: string | LinearGradient;
    bindingContext: any;
    borderBottomColor: Color;
    borderBottomLeftRadius: Length;
    borderBottomRightRadius: Length;
    borderBottomWidth: Length;
    borderColor: string | Color;
    borderLeftColor: Color;
    borderLeftWidth: Length;
    borderRadius: string | Length;
    borderRightColor: Color;
    borderRightWidth: Length;
    borderTopColor: Color;
    borderTopLeftRadius: Length;
    borderTopRightRadius: Length;
    borderTopWidth: Length;
    borderWidth: string | Length;
    changeCssFile(cssFileName: string): void;
    _closeAllModalViewsInternal(): boolean;
    color: Color;
    // (undocumented)
    public static combineMeasuredStates(curState: number, newState): number;
    public createAnimation(options: AnimationDefinition): Animation;
    css: string;
    // (undocumented)
    cssClasses: Set<string>;
    // (undocumented)
    cssPseudoClasses: Set<string>;
    cssType: string;
    // (undocumented)
    _currentHeightMeasureSpec: number;
    // (undocumented)
    _currentWidthMeasureSpec: number;
    public eachChildView(callback: (view: View) => boolean): void;
    // (undocumented)
    _eachLayoutView(callback: (View) => void): void;
    public focus(): boolean;
    // (undocumented)
    _gestureObservers: any;
    // Warning: (ae-forgotten-export) The symbol "Size" needs to be exported by the entry point index.d.ts
    public getActualSize(): Size;
    _getCurrentLayoutBounds(): { left: number; top: number; right: number; bottom: number };
    // (undocumented)
    _getFragmentManager(): any;
    // (undocumented)
    public getGestureObservers(type: GestureTypes): Array<GesturesObserver>;
    // Warning: (ae-forgotten-export) The symbol "Point" needs to be exported by the entry point index.d.ts
    public getLocationInWindow(): Point;
    public getLocationOnScreen(): Point;
    public getLocationRelativeTo(otherView: View): Point;
    public getMeasuredHeight(): number;
    // (undocumented)
    public getMeasuredState(): number;
    public getMeasuredWidth(): number;
    // (undocumented)
    _getNativeViewsCount(): number;
    _getRootModalViews(): Array<ViewBase>
    public getSafeAreaInsets(): { left, top, right, bottom };
    _getValue(property: any): never;
    // (undocumented)
    _goToVisualState(state: string);
    // (undocumented)
    _handleLivesync(context?: { type: string, path: string }): boolean;
    _hasAncestorView(ancestorView: View): boolean;
    height: PercentLength;
    horizontalAlignment: HorizontalAlignment;
    public ios: any;
    iosOverflowSafeArea: boolean;
    iosOverflowSafeAreaEnabled: boolean;
    isEnabled: boolean;
    // (undocumented)
    isLayoutRequired: boolean;
    isLayoutValid: boolean;
    isUserInteractionEnabled: boolean;
    public layout(left: number, top: number, right: number, bottom: number, setFrame?: boolean): void;
    public static layoutChangedEvent: string;
    public static layoutChild(parent: View, child: View, left: number, top: number, right: number, bottom: number): void;
    public layoutNativeView(left: number, top: number, right: number, bottom: number): void;
    _manager: any;
    margin: string | PercentLength;
    marginBottom: PercentLength;
    marginLeft: PercentLength;
    marginRight: PercentLength;
    marginTop: PercentLength;
    public measure(widthMeasureSpec: number, heightMeasureSpec: number): void;
    public static measureChild(parent: View, child: View, widthMeasureSpec: number, heightMeasureSpec: number): { measuredWidth: number; measuredHeight: number };
    minHeight: Length;
    minWidth: Length;
    modal: View;
    // (undocumented)
    _modalParent?: View;
    off(eventNames: string | GestureTypes, callback?: (args: EventData) => void, thisArg?: any);
    on(eventNames: string | GestureTypes, callback: (args: EventData) => void, thisArg?: any);
    on(event: "loaded", callback: (args: EventData) => void, thisArg?: any);
    on(event: "unloaded", callback: (args: EventData) => void, thisArg?: any);
    on(event: "androidBackPressed", callback: (args: EventData) => void, thisArg?: any);
    on(event: "showingModally", callback: (args: ShownModallyData) => void, thisArg?: any): void;
    on(event: "shownModally", callback: (args: ShownModallyData) => void, thisArg?: any);
    _onAttachedToWindow(): void;
    onBackPressed(): boolean;
    _onDetachedFromWindow(): void;
    public onLayout(left: number, top: number, right: number, bottom: number): void;
    // (undocumented)
    _onLivesync(context?: { type: string, path: string }): boolean;
    public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void;
    opacity: number;
    originX: number;
    originY: number;
    // (undocumented)
    _redrawNativeBackground(value: any): void;
    // (undocumented)
    _removeAnimation(animation: Animation): boolean;
    public static resolveSizeAndState(size: number, specSize: number, specMode: number, childMeasuredState: number): number;
    rotate: number;
    scaleX: number;
    scaleY: number;
    _setCurrentLayoutBounds(left: number, top: number, right: number, bottom: number): { boundsChanged: boolean, sizeChanged: boolean };
    _setCurrentMeasureSpecs(widthMeasureSpec: number, heightMeasureSpec: number): boolean;
    public setMeasuredDimension(measuredWidth: number, measuredHeight: number): void;
    // (undocumented)
    _setMinHeightNative(value: Length): void;
    // (undocumented)
    _setMinWidthNative(value: Length): void;
    // (undocumented)
    _setNativeClipToBounds(): void;
    // (undocumented)
    _setNativeViewFrame(nativeView: any, frame: any): void;
    _setValue(property: any, value: any): never;
    public static showingModallyEvent: string;
    public static shownModallyEvent: string;
    translateX: dip;
    translateY: dip;
    // (undocumented)
    _updateEffectiveLayoutValues(
        parentWidthMeasureSize: number,
        parentWidthMeasureMode: number,
        parentHeightMeasureSize: number,
        parentHeightMeasureMode: number): void
    _updateStyleScope(cssFileName?: string, cssString?: string, css?: string): void;
    verticalAlignment: VerticalAlignment;
    visibility: Visibility;
    width: PercentLength;
}

// @public (undocumented)
export abstract class ViewBase extends Observable {
    // Dynamic properties.
    public addPseudoClass(name: string): void;
    // (undocumented)
    public _addView(view: ViewBase, atIndex?: number): void;
    public _addViewCore(view: ViewBase, atIndex?: number): void;
    _addViewToNativeVisualTree(view: ViewBase, atIndex?: number): boolean;
    // (undocumented)
    alignSelf: AlignSelf;
    // (undocumented)
    public android: any;
    // (undocumented)
    public _automaticallyAdjustsScrollViewInsets: boolean;
    public _batchUpdate<T>(callback: () => T): T;
    // Warning: (ae-forgotten-export) The symbol "BindingOptions" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    public bind(options: BindingOptions, source?: Object): void;
    // (undocumented)
    public bindingContext: any;
    // (undocumented)
    callLoaded(): void;
    // (undocumented)
    callUnloaded(): void;
    // (undocumented)
    _childIndexToNativeChildIndex(index?: number): number;
    public className: string;
    closeModal(context?: any): void;
    // (undocumented)
    col: number;
    // (undocumented)
    colSpan: number;
    column: number;
    columnSpan: number;
    // (undocumented)
    _context: any /* android.content.Context */;
    createNativeView(): Object;
    // (undocumented)
    public cssClasses: Set<string>;
    // (undocumented)
    public cssPseudoClasses: Set<string>;
    // (undocumented)
    _cssState: any /* "ui/styling/style-scope" */;
    // (undocumented)
    _defaultPaddingBottom: number;
    // (undocumented)
    _defaultPaddingLeft: number;
    // (undocumented)
    _defaultPaddingRight: number;
    // (undocumented)
    _defaultPaddingTop: number;
    public deletePseudoClass(name: string): void;
    public _dialogClosed(): void;
    disposeNativeView(): void;
    // (undocumented)
    dock: "left" | "top" | "right" | "bottom";
    // (undocumented)
    _domId: number;
    // Warning: (ae-forgotten-export) The symbol "DOMNode" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    domNode: DOMNode;
    public eachChild(callback: (child: ViewBase) => boolean): void;
    // (undocumented)
    public effectiveBorderBottomWidth: number;
    // (undocumented)
    public effectiveBorderLeftWidth: number;
    // (undocumented)
    public effectiveBorderRightWidth: number;
    // (undocumented)
    public effectiveBorderTopWidth: number;
    // (undocumented)
    public effectiveHeight: number;
    // (undocumented)
    effectiveLeft: number;
    // (undocumented)
    public effectiveMarginBottom: number;
    // (undocumented)
    public effectiveMarginLeft: number;
    // (undocumented)
    public effectiveMarginRight: number;
    // (undocumented)
    public effectiveMarginTop: number;
    // (undocumented)
    public effectiveMinHeight: number;
    // (undocumented)
    public effectiveMinWidth: number;
    // (undocumented)
    public effectivePaddingBottom: number;
    // (undocumented)
    public effectivePaddingLeft: number;
    // (undocumented)
    public effectivePaddingRight: number;
    // (undocumented)
    public effectivePaddingTop: number;
    // (undocumented)
    effectiveTop: number;
    // (undocumented)
    public effectiveWidth: number;
    public ensureDomNode();
    // (undocumented)
    flexGrow: FlexGrow;
    // (undocumented)
    flexShrink: FlexShrink;
    // (undocumented)
    flexWrapBefore: FlexWrapBefore;
    public getViewById<T extends ViewBase>(id: string): T;
    // (undocumented)
    public _goToVisualState(state: string): void;
    public id: string;
    // (undocumented)
    _inheritStyleScope(styleScope: any /* StyleScope */): void;
    initNativeView(): void;
    // (undocumented)
    public ios: any;
    // (undocumented)
    _isAddedToNativeVisualTree: boolean;
    public isCollapsed: boolean;
    // (undocumented)
    public readonly isLoaded: boolean;
    // (undocumented)
    public _isPaddingRelative: boolean;
    // (undocumented)
    _isStyleScopeHost: boolean;
    // (undocumented)
    public _layoutParent(): void;
    // (undocumented)
    left: Length;
    public static loadedEvent: string;
    public loadView(view: ViewBase): void;
    _moduleName?: string;
    // (undocumented)
    public nativeView: any;
    public nativeViewProtected: any;
    // (undocumented)
    _oldBottom: number;
    // (undocumented)
    _oldLeft: number;
    // (undocumented)
    _oldRight: number;
    // (undocumented)
    _oldTop: number;
    _onCssStateChange(): void;
    // (undocumented)
    public onLoaded(): void;
    // (undocumented)
    public onResumeNativeUpdates(): void;
    public _onRootViewReset(): void;
    // (undocumented)
    public onUnloaded(): void;
    // (undocumented)
    order: Order;
    public readonly page: Page;
    public readonly parent: ViewBase;
    // (undocumented)
    public _parentChanged(oldParent: ViewBase): void;
    public parentNode: ViewBase;
    // (undocumented)
    public recycleNativeView: "always" | "never" | "auto";
    // (undocumented)
    public _removeView(view: ViewBase): void;
    public _removeViewCore(view: ViewBase): void;
    // (undocumented)
    _removeViewFromNativeVisualTree(view: ViewBase): void;
    public requestLayout(): void;
    resetNativeView(): void;
    // (undocumented)
    row: number;
    // (undocumented)
    rowSpan: number;
    // (undocumented)
    public setInlineStyle(style: string): void;
    setNativeView(view: any): void;
    // (undocumented)
    _setupAsRootView(context: any): void;
    _setupUI(context: any /* android.content.Context */, atIndex?: number): void;
    showModal(moduleName: string, modalOptions: ShowModalOptions): ViewBase;
    showModal(view: ViewBase, modalOptions: ShowModalOptions): ViewBase;
    public readonly style: Style;
    // (undocumented)
    public _styleScope: any;
    _suspendedUpdates: { [propertyName: string]: Property<ViewBase, any> | CssProperty<Style, any> | CssAnimationProperty<Style, any> };
    public _suspendNativeUpdatesCount: number;
    _tearDownUI(force?: boolean): void;
    // (undocumented)
    top: Length;
    public typeName: string;
    // (undocumented)
    public unbind(property: string): void;
    public static unloadedEvent: string;
    public unloadView(view: ViewBase): void;
    public viewController: any;
    //@endprivate
}

// @public
export interface ViewEntry {
    create?: () => View;

    moduleName?: string;
}

// @public
export class WebView extends View {
    android: any /* android.webkit.WebView */;

    canGoBack: boolean;

    canGoForward: boolean;

    goBack();

    goForward();

    ios: any /* WKWebView */;

    public static loadFinishedEvent: string;

    public static loadStartedEvent: string;

    on(eventNames: string, callback: (data: EventData) => void, thisArg?: any);

    // Warning: (ae-forgotten-export) The symbol "LoadEventData" needs to be exported by the entry point index.d.ts
    on(event: "loadFinished", callback: (args: LoadEventData) => void, thisArg?: any);

    on(event: "loadStarted", callback: (args: LoadEventData) => void, thisArg?: any);

    reload();

    src: string;

    stopLoading(): void;
}

// @public
export class WrapLayout extends LayoutBase {

    itemHeight: Length;

    itemWidth: Length;

    // Warning: (ae-forgotten-export) The symbol "Orientation" needs to be exported by the entry point index.d.ts
    orientation: Orientation_3;
}

// @public
export class XmlParser {

    constructor(onEvent: (event: ParserEvent) => void, onError?: (error: Error, position: Position) => void, processNamespaces?: boolean, angularSyntax?: boolean);

    parse(xmlString: string): void;
}


// Warnings were encountered during analysis:
//
// nativescript-core/index.d.ts:15:5 - (ae-forgotten-export) The symbol "getMainEntry" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:16:5 - (ae-forgotten-export) The symbol "getRootView" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:17:5 - (ae-forgotten-export) The symbol "setResources" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:18:5 - (ae-forgotten-export) The symbol "setCssFileName" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:19:5 - (ae-forgotten-export) The symbol "getCssFileName" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:20:5 - (ae-forgotten-export) The symbol "loadAppCss" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:21:5 - (ae-forgotten-export) The symbol "addCss" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:22:5 - (ae-forgotten-export) The symbol "on" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:23:5 - (ae-forgotten-export) The symbol "off" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:24:5 - (ae-forgotten-export) The symbol "run" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:25:5 - (ae-forgotten-export) The symbol "orientation" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:26:5 - (ae-forgotten-export) The symbol "getNativeApplication" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:27:5 - (ae-forgotten-export) The symbol "hasLaunched" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:33:5 - (ae-forgotten-export) The symbol "clear" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:34:5 - (ae-forgotten-export) The symbol "flush" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:35:5 - (ae-forgotten-export) The symbol "hasKey" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:36:5 - (ae-forgotten-export) The symbol "remove" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:37:5 - (ae-forgotten-export) The symbol "setString" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:38:5 - (ae-forgotten-export) The symbol "getString" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:39:5 - (ae-forgotten-export) The symbol "getAllKeys" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:40:5 - (ae-forgotten-export) The symbol "getBoolean" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:41:5 - (ae-forgotten-export) The symbol "setBoolean" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:42:5 - (ae-forgotten-export) The symbol "getNumber" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:43:5 - (ae-forgotten-export) The symbol "setNumber" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:48:5 - (ae-forgotten-export) The symbol "connectionType" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:49:5 - (ae-forgotten-export) The symbol "getConnectionType" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:50:5 - (ae-forgotten-export) The symbol "startMonitoring" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:51:5 - (ae-forgotten-export) The symbol "stopMonitoring" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:59:5 - (ae-forgotten-export) The symbol "getFile" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:60:5 - (ae-forgotten-export) The symbol "getImage" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:61:5 - (ae-forgotten-export) The symbol "getJSON" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:62:5 - (ae-forgotten-export) The symbol "getString" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:63:5 - (ae-forgotten-export) The symbol "request" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:71:5 - (ae-forgotten-export) The symbol "enable" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:72:5 - (ae-forgotten-export) The symbol "disable" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:73:5 - (ae-forgotten-export) The symbol "time" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:74:5 - (ae-forgotten-export) The symbol "uptime" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:75:5 - (ae-forgotten-export) The symbol "start" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:76:5 - (ae-forgotten-export) The symbol "stop" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:77:5 - (ae-forgotten-export) The symbol "isRunning" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:78:5 - (ae-forgotten-export) The symbol "dumpProfiles" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:79:5 - (ae-forgotten-export) The symbol "resetProfiles" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:80:5 - (ae-forgotten-export) The symbol "profile" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:81:5 - (ae-forgotten-export) The symbol "startCPUProfile" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:82:5 - (ae-forgotten-export) The symbol "stopCPUProfile" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:88:5 - (ae-forgotten-export) The symbol "messageType" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:89:5 - (ae-forgotten-export) The symbol "categories" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:90:5 - (ae-forgotten-export) The symbol "setCategories" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:91:5 - (ae-forgotten-export) The symbol "addCategories" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:92:5 - (ae-forgotten-export) The symbol "addWriter" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:93:5 - (ae-forgotten-export) The symbol "removeWriter" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:94:5 - (ae-forgotten-export) The symbol "clearWriters" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:95:5 - (ae-forgotten-export) The symbol "setErrorHandler" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:96:5 - (ae-forgotten-export) The symbol "write" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:97:5 - (ae-forgotten-export) The symbol "error" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:98:5 - (ae-forgotten-export) The symbol "enable" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:99:5 - (ae-forgotten-export) The symbol "disable" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:100:5 - (ae-forgotten-export) The symbol "isEnabled" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:105:5 - (ae-forgotten-export) The symbol "GC" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:106:5 - (ae-forgotten-export) The symbol "isFontIconURI" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:107:5 - (ae-forgotten-export) The symbol "isDataURI" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:108:5 - (ae-forgotten-export) The symbol "isFileOrResourcePath" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:109:5 - (ae-forgotten-export) The symbol "executeOnMainThread" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:110:5 - (ae-forgotten-export) The symbol "mainThreadify" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:111:5 - (ae-forgotten-export) The symbol "isMainThread" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:112:5 - (ae-forgotten-export) The symbol "dispatchToMainThread" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:113:5 - (ae-forgotten-export) The symbol "releaseNativeObject" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:114:5 - (ae-forgotten-export) The symbol "getModuleName" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:115:5 - (ae-forgotten-export) The symbol "openFile" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:116:5 - (ae-forgotten-export) The symbol "openUrl" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:117:5 - (ae-forgotten-export) The symbol "layout" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:118:5 - (ae-forgotten-export) The symbol "ad" needs to be exported by the entry point index.d.ts
// nativescript-core/index.d.ts:119:5 - (ae-forgotten-export) The symbol "ios" needs to be exported by the entry point index.d.ts
// nativescript-core/ui/core/view-base/view-base.d.ts:179:26 - (ae-forgotten-export) The symbol "Property" needs to be exported by the entry point index.d.ts
// nativescript-core/ui/core/view-base/view-base.d.ts:179:26 - (ae-forgotten-export) The symbol "CssProperty" needs to be exported by the entry point index.d.ts
// nativescript-core/ui/core/view-base/view-base.d.ts:179:26 - (ae-forgotten-export) The symbol "CssAnimationProperty" needs to be exported by the entry point index.d.ts

// (No @packageDocumentation comment for this package)

```