@octane-xplat/lottie 0.0.1 → 0.10.0

package/src/vendor/ui-lottie/src/lottie/typings/android.nativescript.d.ts

@@ -0,0 +1,12 @@
+
+declare module com {
+	export module nativescript {
+		export module lottie {
+			export class LottieAnimationView extends com.airbnb.lottie.LottieAnimationView {
+				public static class: java.lang.Class<com.nativescript.lottie.LottieAnimationView>;
+				public constructor(param0: globalAndroid.content.Context);
+				public onMeasure(param0: number, param1: number): void;
+			}
+		}
+	}
+}

package/src/vendor/ui-lottie/src/lottie/typings/dotlottie.ios.d.ts

@@ -0,0 +1,14 @@
+
+declare class DotLottie extends NSObject {
+
+    static alloc(): DotLottie; // inherited from NSObject
+
+    static new(): DotLottie; // inherited from NSObject
+
+    static objcLoadWithNameShouldCacheCompletion(name: string, shouldCache: boolean, completion: (p1: Animation) => void): void;
+    static objcLoadFromShouldCacheCompletion(url: NSURL, shouldCache: boolean, completion: (p1: Animation) => void): void;
+}
+
+declare let dotLottieVersionNumber: number;
+
+declare let dotLottieVersionString: interop.Reference<number>;

package/src/vendor/ui-lottie/src/lottie/typings/ios.d.ts

@@ -0,0 +1,384 @@
+/* eslint-disable @typescript-eslint/unified-signatures */
+declare class AnimatedButton extends AnimatedControl {
+    static alloc(): AnimatedButton; // inherited from NSObject
+
+    static appearance(): AnimatedButton; // inherited from UIAppearance
+
+    static appearanceForTraitCollection(trait: UITraitCollection): AnimatedButton; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedIn(trait: UITraitCollection, ContainerClass: typeof NSObject): AnimatedButton; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedInInstancesOfClasses(
+        trait: UITraitCollection,
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): AnimatedButton; // inherited from UIAppearance
+
+    static appearanceWhenContainedIn(ContainerClass: typeof NSObject): AnimatedButton; // inherited from UIAppearance
+
+    static appearanceWhenContainedInInstancesOfClasses(
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): AnimatedButton; // inherited from UIAppearance
+
+    static new(): AnimatedButton; // inherited from NSObject
+}
+
+declare class AnimatedControl extends UIControl {
+    static alloc(): AnimatedControl; // inherited from NSObject
+
+    static appearance(): AnimatedControl; // inherited from UIAppearance
+
+    static appearanceForTraitCollection(trait: UITraitCollection): AnimatedControl; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedIn(
+        trait: UITraitCollection,
+        ContainerClass: typeof NSObject
+    ): AnimatedControl; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedInInstancesOfClasses(
+        trait: UITraitCollection,
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): AnimatedControl; // inherited from UIAppearance
+
+    static appearanceWhenContainedIn(ContainerClass: typeof NSObject): AnimatedControl; // inherited from UIAppearance
+
+    static appearanceWhenContainedInInstancesOfClasses(
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): AnimatedControl; // inherited from UIAppearance
+
+    static new(): AnimatedControl; // inherited from NSObject
+}
+
+declare class AnimatedSwitch extends AnimatedControl {
+    static alloc(): AnimatedSwitch; // inherited from NSObject
+
+    static appearance(): AnimatedSwitch; // inherited from UIAppearance
+
+    static appearanceForTraitCollection(trait: UITraitCollection): AnimatedSwitch; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedIn(trait: UITraitCollection, ContainerClass: typeof NSObject): AnimatedSwitch; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedInInstancesOfClasses(
+        trait: UITraitCollection,
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): AnimatedSwitch; // inherited from UIAppearance
+
+    static appearanceWhenContainedIn(ContainerClass: typeof NSObject): AnimatedSwitch; // inherited from UIAppearance
+
+    static appearanceWhenContainedInInstancesOfClasses(
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): AnimatedSwitch; // inherited from UIAppearance
+
+    static new(): AnimatedSwitch; // inherited from NSObject
+}
+
+declare class AnimationSubview extends UIView {
+    static alloc(): AnimationSubview; // inherited from NSObject
+
+    static appearance(): AnimationSubview; // inherited from UIAppearance
+
+    static appearanceForTraitCollection(trait: UITraitCollection): AnimationSubview; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedIn(
+        trait: UITraitCollection,
+        ContainerClass: typeof NSObject
+    ): AnimationSubview; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedInInstancesOfClasses(
+        trait: UITraitCollection,
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): AnimationSubview; // inherited from UIAppearance
+
+    static appearanceWhenContainedIn(ContainerClass: typeof NSObject): AnimationSubview; // inherited from UIAppearance
+
+    static appearanceWhenContainedInInstancesOfClasses(
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): AnimationSubview; // inherited from UIAppearance
+
+    static new(): AnimationSubview; // inherited from NSObject
+}
+
+declare class CompatibleAnimation extends NSObject {
+    static alloc(): CompatibleAnimation; // inherited from NSObject
+
+    static new(): CompatibleAnimation; // inherited from NSObject
+
+    constructor(o: { filepath: string });
+
+    constructor(o: { json: string });
+
+    constructor(o: { name: string; bundle: NSBundle });
+
+    constructor(o: { name: string; subdirectory: string; bundle: NSBundle });
+
+    initWithFilepath(filepath: string): this;
+
+    initWithJson(json: string): this;
+
+    initWithNameBundle(name: string, bundle: NSBundle): this;
+
+    initWithNameSubdirectoryBundle(name: string, subdirectory: string, bundle: NSBundle): this;
+}
+
+declare class CompatibleAnimationKeypath extends NSObject {
+    static alloc(): CompatibleAnimationKeypath; // inherited from NSObject
+
+    static new(): CompatibleAnimationKeypath; // inherited from NSObject
+
+    constructor(o: { keypath: string });
+
+    constructor(o: { keys: NSArray<string> | string[] });
+
+    initWithKeypath(keypath: string): this;
+
+    initWithKeys(keys: NSArray<string> | string[]): this;
+}
+
+declare class CompatibleAnimationView extends UIView {
+    static alloc(): CompatibleAnimationView; // inherited from NSObject
+
+    static appearance(): CompatibleAnimationView; // inherited from UIAppearance
+
+    static appearanceForTraitCollection(trait: UITraitCollection): CompatibleAnimationView; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedIn(
+        trait: UITraitCollection,
+        ContainerClass: typeof NSObject
+    ): CompatibleAnimationView; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedInInstancesOfClasses(
+        trait: UITraitCollection,
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): CompatibleAnimationView; // inherited from UIAppearance
+
+    static appearanceWhenContainedIn(ContainerClass: typeof NSObject): CompatibleAnimationView; // inherited from UIAppearance
+
+    static appearanceWhenContainedInInstancesOfClasses(
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): CompatibleAnimationView; // inherited from UIAppearance
+
+    static new(): CompatibleAnimationView; // inherited from NSObject
+
+    animation: LottieAnimation;
+
+    readonly animationDuration: number;
+
+    animationSpeed: number;
+
+    backgroundMode: CompatibleBackgroundBehavior;
+
+    compatibleAnimation: CompatibleAnimation;
+
+    compatibleDictionaryTextProvider: CompatibleDictionaryTextProvider;
+
+    currentFrame: number;
+
+    currentProgress: number;
+
+    currentTime: number;
+
+    readonly duration: number;
+
+    readonly isAnimationPlaying: boolean;
+
+    loopAnimationCount: number;
+
+    readonly realtimeAnimationFrame: number;
+
+    readonly realtimeAnimationProgress: number;
+
+    respectAnimationFrameRate: boolean;
+
+    shouldRasterizeWhenIdle: boolean;
+
+    constructor(o: { compatibleAnimation: CompatibleAnimation });
+
+    constructor(o: {
+        compatibleAnimation: CompatibleAnimation;
+        compatibleRenderingEngineOption: CompatibleRenderingEngineOption;
+    });
+
+    constructor(o: { data: NSData });
+
+    constructor(o: { data: NSData; compatibleRenderingEngineOption: CompatibleRenderingEngineOption });
+
+    constructor(o: { url: NSURL });
+
+    constructor(o: { url: NSURL; compatibleRenderingEngineOption: CompatibleRenderingEngineOption });
+
+    addSubviewForLayerAt(subview: AnimationSubview, keypath: CompatibleAnimationKeypath): void;
+
+    convertWithPointToLayerAt(point: CGPoint, keypath: CompatibleAnimationKeypath): CGPoint;
+
+    convertWithRectToLayerAt(rect: CGRect, keypath: CompatibleAnimationKeypath): CGRect;
+
+    durationFrameTimeForMarker(named: string): number;
+
+    forceDisplayUpdate(): void;
+
+    frameTimeForMarker(named: string): number;
+
+    getColorValueForAtFrame(keypath: CompatibleAnimationKeypath, atFrame: number): UIColor;
+
+    getFloatValueForAtFrame(keypath: CompatibleAnimationKeypath, atFrame: number): number;
+
+    getValueForAtFrame(keypath: CompatibleAnimationKeypath, atFrame: number): any;
+
+    initWithCompatibleAnimation(compatibleAnimation: CompatibleAnimation): this;
+
+    initWithCompatibleAnimationCompatibleRenderingEngineOption(
+        compatibleAnimation: CompatibleAnimation,
+        compatibleRenderingEngineOption: CompatibleRenderingEngineOption
+    ): this;
+
+    initWithData(data: NSData): this;
+
+    initWithDataCompatibleRenderingEngineOption(
+        data: NSData,
+        compatibleRenderingEngineOption: CompatibleRenderingEngineOption
+    ): this;
+
+    initWithUrl(url: NSURL): this;
+
+    initWithUrlCompatibleRenderingEngineOption(
+        url: NSURL,
+        compatibleRenderingEngineOption: CompatibleRenderingEngineOption
+    ): this;
+
+    logHierarchyKeypaths(): void;
+
+    pause(): void;
+
+    play(): void;
+
+    playFromFrameToFrameCompletion(fromFrame: number, toFrame: number, completion: (p1: boolean) => void): void;
+
+    playFromMarkerToMarkerCompletion(fromMarker: string, toMarker: string, completion: (p1: boolean) => void): void;
+
+    playFromProgressToProgressCompletion(fromProgress: number, toProgress: number, completion: (p1: boolean) => void): void;
+
+    playWithCompletion(completion: (p1: boolean) => void): void;
+
+    playWithMarkerCompletion(marker: string, completion: (p1: boolean) => void): void;
+
+    progressTimeForMarker(named: string): number;
+
+    reloadImages(): void;
+
+    setColorValueForKeypath(color: UIColor, keypath: CompatibleAnimationKeypath): void;
+
+    setFloatValueForKeypath(value: number, keypath: CompatibleAnimationKeypath): void;
+
+    stop(): void;
+}
+
+declare const enum CompatibleBackgroundBehavior {
+    Stop = 0,
+
+    Pause = 1,
+
+    PauseAndRestore = 2,
+
+    ForceFinish = 3,
+
+    ContinuePlaying = 4
+}
+
+declare class CompatibleDictionaryTextProvider extends NSObject {
+    static alloc(): CompatibleDictionaryTextProvider; // inherited from NSObject
+
+    static new(): CompatibleDictionaryTextProvider; // inherited from NSObject
+
+    constructor(o: { values: NSDictionary<string, string> });
+
+    initWithValues(values: NSDictionary<string, string>): this;
+}
+
+declare class CompatibleLottieLogger extends NSObject {
+    static alloc(): CompatibleLottieLogger; // inherited from NSObject
+
+    static new(): CompatibleLottieLogger; // inherited from NSObject
+
+    static overrideLottieLogger(): void;
+}
+
+declare const enum CompatibleRenderingEngineOption {
+    Shared = 0,
+
+    DefaultEngine = 1,
+
+    Automatic = 2,
+
+    MainThread = 3,
+
+    CoreAnimation = 4
+}
+
+declare class LottieAnimation extends NSObject {
+    static alloc(): LottieAnimation; // inherited from NSObject
+
+    static new(): LottieAnimation; // inherited from NSObject
+}
+
+declare class LottieAnimationLayer extends CALayer {
+    static alloc(): LottieAnimationLayer; // inherited from NSObject
+
+    static layer(): LottieAnimationLayer; // inherited from CALayer
+
+    static new(): LottieAnimationLayer; // inherited from NSObject
+}
+
+declare class LottieAnimationView extends LottieAnimationViewBase {
+    static alloc(): LottieAnimationView; // inherited from NSObject
+
+    static appearance(): LottieAnimationView; // inherited from UIAppearance
+
+    static appearanceForTraitCollection(trait: UITraitCollection): LottieAnimationView; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedIn(
+        trait: UITraitCollection,
+        ContainerClass: typeof NSObject
+    ): LottieAnimationView; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedInInstancesOfClasses(
+        trait: UITraitCollection,
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): LottieAnimationView; // inherited from UIAppearance
+
+    static appearanceWhenContainedIn(ContainerClass: typeof NSObject): LottieAnimationView; // inherited from UIAppearance
+
+    static appearanceWhenContainedInInstancesOfClasses(
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): LottieAnimationView; // inherited from UIAppearance
+
+    static new(): LottieAnimationView; // inherited from NSObject
+}
+
+declare class LottieAnimationViewBase extends UIView {
+    static alloc(): LottieAnimationViewBase; // inherited from NSObject
+
+    static appearance(): LottieAnimationViewBase; // inherited from UIAppearance
+
+    static appearanceForTraitCollection(trait: UITraitCollection): LottieAnimationViewBase; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedIn(
+        trait: UITraitCollection,
+        ContainerClass: typeof NSObject
+    ): LottieAnimationViewBase; // inherited from UIAppearance
+
+    static appearanceForTraitCollectionWhenContainedInInstancesOfClasses(
+        trait: UITraitCollection,
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): LottieAnimationViewBase; // inherited from UIAppearance
+
+    static appearanceWhenContainedIn(ContainerClass: typeof NSObject): LottieAnimationViewBase; // inherited from UIAppearance
+
+    static appearanceWhenContainedInInstancesOfClasses(
+        containerTypes: NSArray<typeof NSObject> | typeof NSObject[]
+    ): LottieAnimationViewBase; // inherited from UIAppearance
+
+    static new(): LottieAnimationViewBase; // inherited from NSObject
+}
+
+declare let LottieVersionNumber: number;
+
+declare let LottieVersionString: interop.Reference<number>;

package/src/vendor/ui-lottie/src/lottie/utils.ts

@@ -0,0 +1,9 @@
+// Vendored from @nativescript-community/ui-lottie (MIT), fork branch
+// xplat-fixes on octane-xplat/ui-lottie — device-probed fixes for dead
+// sync-src, missing events/pause-resume, URL/.lottie sources, async
+// autoPlay, completion dedupe, opacity scale, Podfile pin.
+// @ts-nocheck — vendored upstream code, not strict-clean; kept
+// diff-identical to the fork so fix branches stay PR-able.
+export function clamp(val: number, min: number = 0, max: number = 1) {
+    return val > max ? max : val < min ? min : val;
+}

package/types/generated/.tsrx-typegen-manifest.json

@@ -0,0 +1,18 @@
+{
+  "version": 1,
+  "files": [
+    "Lottie.d.ts",
+    "Lottie.web.d.ts",
+    "cx.mobile.d.ts",
+    "escape-props.d.ts",
+    "escape-props.web.d.ts",
+    "index.d.ts",
+    "index.web.d.ts",
+    "layout-child.d.ts",
+    "layout-child.web.d.ts",
+    "props.d.ts",
+    "vendor/ui-lottie/src/lottie/index.common.d.ts",
+    "vendor/ui-lottie/src/lottie/index.ios.d.ts",
+    "vendor/ui-lottie/src/lottie/utils.d.ts"
+  ]
+}

package/types/generated/Lottie.d.ts

@@ -0,0 +1,7 @@
+import type { LottieProps } from './props.js';
+/**  Lottie — vendored ui-lottie surface (see src/plugin). The plugin
+ *  doesn't diff props, so src/play-state/speed/progress land imperatively
+ *  in effects. `async` stays forced on: it keeps the load path uniform
+ *  (one code path for inline/file/URL/.lottie) and avoids main-thread
+ *  parse jank; autoPlay is re-applied when the composition lands. */
+export declare function Lottie(props: LottieProps): unknown;

package/types/generated/Lottie.web.d.ts

@@ -0,0 +1,7 @@
+import type { LottieProps } from './props.js';
+/**  Lottie — lottie-web's svg renderer in a plain container div. Everything
+ *  is imperative: `src`/`data` rebuild the AnimationItem, the rest are
+ *  method calls applied in effects. Progress is normalized 0..1
+ *  (lottie-web speaks frames); durations arrive in seconds and are
+ *  surfaced as ms. */
+export declare function Lottie(props: LottieProps): import("octane/jsx-runtime").JSX.Element;

package/types/generated/cx.mobile.d.ts

@@ -0,0 +1,6 @@
+/** NS `className` splits on ' ' only, and the universal driver applies the
+ *  prop via `String(value)` — an array would arrive comma-joined and match
+ *  no class at all. Native leaves normalize through cx() before handing
+ *  className to an intrinsic. (The DOM renderer already flattens arrays,
+ *  so web leaves don't need this.) */
+export declare function cx(...parts: any[]): string;

package/types/generated/escape-props.d.ts

@@ -0,0 +1,15 @@
+import type { Role } from './props.js';
+/** Apply only the active device's escape bag after the primitive's own props. */
+export declare function applyEscapeProps(view: any, props: {
+    ios?: any;
+    android?: any;
+}): void;
+/** Translate the shared/ARIA spelling to NativeScript's narrower role enum. */
+export declare function nativeAccessibilityRole(role?: Role): string | undefined;
+/** NativeScript's AccessibilityState is a single enum value, unlike the
+ *  web's independent ARIA booleans. Priority follows the strongest state. */
+export declare function nativeAccessibilityState(state?: {
+    disabled?: boolean;
+    selected?: boolean;
+    checked?: boolean;
+}): string | undefined;

package/types/generated/escape-props.web.d.ts

@@ -0,0 +1,5 @@
+/** Apply DOM escape props after the primitive's own props. Dash-named keys
+ *  are attributes; other keys use the DOM property where available. */
+export declare function applyEscapeProps(element: any, props: {
+    web?: any;
+}): void;

package/types/generated/index.d.ts

@@ -0,0 +1,2 @@
+export { Lottie } from './Lottie.js';
+export type { LottieEvent, LottieFit, LottieHandle, LottieProps } from './props.js';

package/types/generated/index.web.d.ts

@@ -0,0 +1,2 @@
+export { Lottie } from './Lottie.web.js';
+export type { LottieEvent, LottieFit, LottieHandle, LottieProps } from './props.js';

package/types/generated/layout-child.d.ts

@@ -0,0 +1,6 @@
+import type { LayoutChildProps, FlexContainerProps } from './props.js';
+/** NativeScript reads these attributes from each child view during parent
+ *  layout. Values are forwarded with NativeScript's own property names.
+ *  The flex-container props (justifyContent/alignItems/flexWrap/gap) land on
+ *  the host flexboxlayout itself — its own attributes, not child metadata. */
+export declare function layoutChildProps(props: LayoutChildProps & Partial<FlexContainerProps>): Record<string, any>;

package/types/generated/layout-child.web.d.ts

@@ -0,0 +1,15 @@
+import type { LayoutChildProps, FlexContainerProps } from './props.js';
+/** The shared contract is "numbers are dips" (RN semantics), but octane's DOM
+ *  renderer keeps React's unitless list — lineHeight is unitless there, so
+ *  `style={{lineHeight: 40}}` would render a 40× multiplier instead of 40px.
+ *  lineHeight is the one unitless-in-React prop that is a length in the
+ *  shared vocabulary; force the px suffix. */
+export declare function normStyle(style: any): any;
+/** Convert parent-layout metadata to CSS on the web leaf. Native's `dock`
+ *  attribute has no CSS equivalent and is ignored on web. Grid indices are
+ *  zero-based in the shared API, matching NativeScript. */
+export declare function layoutChildProps(props: LayoutChildProps & Partial<FlexContainerProps> & {
+    style?: any;
+}, baseStyle?: any): {
+    style: any;
+};

package/types/generated/props.d.ts

@@ -0,0 +1,110 @@
+import type { Octane } from 'octane/jsx-runtime';
+export interface LayoutChildProps {
+    row?: number;
+    col?: number;
+    rowSpan?: number;
+    colSpan?: number;
+    dock?: 'left' | 'top' | 'right' | 'bottom';
+    left?: number;
+    top?: number;
+    flexGrow?: number;
+    flexShrink?: number;
+    alignSelf?: string;
+    order?: number;
+}
+/** Flex-container props shared by View/Row/Pressable — RN vocabulary, applied
+ *  to the host flexboxlayout natively and the element's style on web.
+ *  `gap` is a dip number (px on web); NS supports it on FlexboxLayout only. */
+export interface FlexContainerProps {
+    justifyContent?: 'start' | 'center' | 'end' | 'space-between' | 'space-around' | 'space-evenly';
+    alignItems?: 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+    flexWrap?: boolean | 'wrap' | 'nowrap' | 'wrap-reverse';
+    gap?: number | string;
+    rowGap?: number | string;
+    columnGap?: number | string;
+}
+export type Role = 'button' | 'link' | 'search' | 'image' | 'heading' | 'adjustable' | 'summary' | 'text' | 'none' | 'progressbar' | 'checkbox' | 'switch' | 'radio' | 'spinbutton' | 'tab';
+export interface AccessibilityProps {
+    accessible?: boolean;
+    accessibilityLabel?: string;
+    accessibilityRole?: Role;
+    accessibilityHint?: string;
+    accessibilityValue?: string;
+    accessibilityState?: {
+        disabled?: boolean;
+        selected?: boolean;
+        checked?: boolean;
+    };
+    accessibilityLiveRegion?: 'none' | 'polite' | 'assertive';
+}
+export type LottieFit = 'contain' | 'cover' | 'fill';
+export interface LottieEvent {
+    /** Animation duration in milliseconds once loaded (0 before then). */
+    duration?: number;
+    /** Failure description. */
+    message?: string;
+}
+export interface LottieHandle {
+    play(): void;
+    pause(): void;
+    /** Stop and reset the playhead to the start. */
+    stop(): void;
+    /** Seek to a normalized position, 0..1. */
+    seekTo(progress: number): void;
+    /** Playback speed multiplier (1 = normal). */
+    setSpeed(n: number): void;
+    /** Current playhead position, 0..1. */
+    progress(): number;
+    /** Animation duration in milliseconds (0 before load). */
+    duration(): number;
+    isPlaying(): boolean;
+    /** The platform surface (lottie-web AnimationItem / plugin LottieView). */
+    native: any;
+}
+/** Lottie animation — lottie-web (svg renderer) on web, vendored
+ *  ui-lottie (`src/vendor/ui-lottie` submodule, `octane-xplat/ui-lottie`
+ *  @ `xplat-vendored`) on native.
+ *  On web, lottie-web evaluates expressions embedded in animation data as
+ *  JavaScript. Load only trusted animation data; expression-bearing files
+ *  require a CSP that allows `unsafe-eval`.
+ *  Progress is always normalized 0..1 and durations are milliseconds on
+ *  every platform (the native plugin reports seconds on iOS). */
+export interface LottieProps extends LayoutChildProps, AccessibilityProps {
+    className?: any;
+    style?: any;
+    id?: string;
+    /** Remote URL; native also accepts `~/` bundle paths, absolute file
+     *  paths, `res://` names, `.lottie`/`.zip` containers, and raw JSON
+     *  strings starting with `{`. */
+    src?: string;
+    /** Inline animation object — wins over `src` when both are given. */
+    data?: object;
+    /** Start playing as soon as the composition loads. Default true —
+     *  matches lottie-web; the native plugin's own default is false. */
+    autoPlay?: boolean;
+    /** Repeat forever. Default false — a finite play is the least
+     *  surprising shared contract (lottie-web's own default is true). */
+    loop?: boolean;
+    /** Controlled playback — leave unset for uncontrolled play. */
+    playing?: boolean;
+    /** Controlled playhead position, 0..1. */
+    progress?: number;
+    /** Playback speed multiplier (1 = normal). */
+    speed?: number;
+    /** Content fitting inside the frame: `contain` (letterbox, default),
+     *  `cover` (crop to fill), `fill` (stretch). */
+    fit?: LottieFit;
+    /** Composition parsed and ready — `e.duration` is the length in ms. */
+    onLoaded?: (e: LottieEvent) => void;
+    /** Reached the end; does not fire per loop iteration. */
+    onEnded?: () => void;
+    /** Load or parse failure. */
+    onError?: (e: LottieEvent) => void;
+    /** Imperative handle — play/pause/seek plus `native` for anything the
+     *  shared props don't cover. */
+    ref?: Octane.Ref<LottieHandle>;
+    /** Platform escape hatches, applied after the shared props. */
+    ios?: Record<string, any>;
+    android?: Record<string, any>;
+    web?: Record<string, any>;
+}

package/types/generated/vendor/ui-lottie/src/lottie/index.common.d.ts

@@ -0,0 +1,30 @@
+/**********************************************************************************
+ * (c) 2017, Nathan Walker.
+ * Licensed under the MIT license.
+ *
+ * Version 1.0.0                                           walkerrunpdx@gmail.com
+ **********************************************************************************/
+import { CoreTypes, Property, View } from '@nativescript/core';
+export interface KeyPathColors {
+    [k: string]: Color | string;
+}
+export declare class LottieViewBase extends View {
+    static compositionLoadedEvent: string;
+    static loadFailedEvent: string;
+    stretch: CoreTypes.ImageStretchType;
+    async: boolean;
+    src: string;
+    loop: boolean;
+    autoPlay: boolean;
+    progress: number;
+    keyPathColors: KeyPathColors;
+    completionBlock: (animationFinished: boolean) => void;
+}
+export declare const srcProperty: Property<LottieViewBase, string>;
+export declare const asyncProperty: Property<LottieViewBase, boolean>;
+export declare const loopProperty: Property<LottieViewBase, boolean>;
+export declare const autoPlayProperty: Property<LottieViewBase, boolean>;
+export declare const renderModeProperty: Property<LottieViewBase, number>;
+export declare const progressProperty: Property<LottieViewBase, number>;
+export declare const stretchProperty: Property<LottieViewBase, CoreTypes.ImageStretchType>;
+export declare const keyPathColorsProperty: Property<LottieViewBase, KeyPathColors>;