peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-engine/src/engine/types.d.ts

@@ -0,0 +1,657 @@
+import type { UIBlurMaterialStyle } from '../../../peach-kit/src/materials/uikit-blur-material.d.ts';
+import type { LoupeState } from '../render-worker/text-inputContract.d.ts';
+import type { CanvasKitRenderingApi as CanvasKit } from './canvaskit-api.d.ts';
+import type { DamageRect } from './damage-rect.d.ts';
+import type { LiquidGlassConfig, LiquidGlassEdgeConfig } from './liquid-glass.d.ts';
+import type { MetalShaderEffectFilter } from './metalShaderContract.d.ts';
+import type { SootSimNode } from './node.d.ts';
+import type { NativeWindowPortalLayer } from './portalContract.d.ts';
+import type { FrameDamage } from './render-damage.d.ts';
+import type { AttributedParagraphStyle } from './text-paragraphContract.d.ts';
+import type { NumericTextPaintRequest } from '../../../peach-globals/src/index.d.ts';
+import type { Surface, Canvas, FontMgr, Image as SkImage } from 'canvaskit-wasm';
+export type Falsy = undefined | null | false;
+export type RecursiveArray<T> = Array<T | RecursiveArray<T>>;
+export type StyleProp<T> = T | RecursiveArray<T | Falsy> | Falsy;
+export type SootSimNodeType = 'root' | 'view' | 'text' | 'image' | 'lottie' | 'scrollview' | 'portal-host' | 'portal-view' | 'masked-view' | 'svg-root' | 'svg-path' | 'svg-circle' | 'svg-rect' | 'svg-line' | 'svg-g' | 'svg-ellipse' | 'svg-polygon' | 'svg-polyline' | 'svg-defs' | 'svg-clippath' | 'svg-lineargradient' | 'svg-radialgradient' | 'svg-stop' | 'svg-mask' | 'svg-text' | 'svg-tspan' | 'svg-use' | 'svg-symbol' | 'svg-marker' | 'svg-pattern' | 'svg-foreignobject' | 'svg-image' | 'svg-textpath' | 'svg-filter' | 'svg-feblend' | 'svg-fecolormatrix' | 'svg-fecomposite' | 'svg-feflood' | 'svg-fegaussianblur' | 'svg-femerge' | 'svg-feoffset';
+export declare const TYPE_MAP: Record<string, SootSimNodeType>;
+export type DynamicColorVariants = {
+    light: string;
+    dark: string;
+    highContrastLight?: string;
+    highContrastDark?: string;
+};
+export type DynamicColor = {
+    dynamic: DynamicColorVariants;
+};
+export declare const dynamicColor: (light: string, dark: string, highContrast?: {
+    light: string;
+    dark: string;
+}) => string;
+export interface BoxShadowValue {
+    offsetX?: number | string;
+    offsetY?: number | string;
+    blurRadius?: number | string;
+    spreadDistance?: number | string;
+    color?: string;
+    inset?: boolean;
+}
+export interface ParsedBoxShadow {
+    offsetX: number;
+    offsetY: number;
+    blurRadius: number;
+    spreadDistance: number;
+    color: string;
+    inset: boolean;
+}
+export interface FilterValue {
+    brightness?: number | string;
+    blur?: number | string;
+    contrast?: number | string;
+    grayscale?: number | string;
+    hueRotate?: number | string;
+    invert?: number | string;
+    opacity?: number | string;
+    saturate?: number | string;
+    sepia?: number | string;
+    dropShadow?: string | {
+        offsetX?: number | string;
+        offsetY?: number | string;
+        standardDeviation?: number | string;
+        color?: string;
+    };
+    _colorMatrix?: number[];
+    _colorMultiply?: unknown;
+    _luminanceToAlpha?: boolean;
+    _metalShaderEffect?: unknown;
+}
+export interface CssLengthPct {
+    v: number;
+    unit: 'fraction' | 'px';
+}
+export type CssGradientCorner = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+export interface BackgroundLength {
+    value: number;
+    unit: 'px' | 'pct';
+}
+export type BackgroundSizeEntry = {
+    kind: 'cover';
+} | {
+    kind: 'contain';
+} | {
+    kind: 'length';
+    x: BackgroundLength | null;
+    y: BackgroundLength | null;
+};
+export interface BackgroundPositionEntry {
+    top?: BackgroundLength;
+    left?: BackgroundLength;
+    right?: BackgroundLength;
+    bottom?: BackgroundLength;
+}
+export type BackgroundRepeatStyle = 'repeat' | 'space' | 'round' | 'no-repeat';
+export interface BackgroundRepeatEntry {
+    x: BackgroundRepeatStyle;
+    y: BackgroundRepeatStyle;
+}
+type GradientInterpolation = 'oklab' | 'unpremultiplied';
+type GradientShape = {
+    type: 'linear';
+    colors: string[];
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    cssAngle?: number;
+    cssCorner?: CssGradientCorner;
+    center?: {
+        x: number;
+        y: number;
+    };
+    locations?: number[];
+} | {
+    type: 'radial';
+    shape: 'circle' | 'ellipse';
+    sizeKeyword?: 'closest-side' | 'closest-corner' | 'farthest-side' | 'farthest-corner';
+    rxValue?: CssLengthPct;
+    ryValue?: CssLengthPct;
+    cx: CssLengthPct;
+    cy: CssLengthPct;
+    colors: string[];
+    locations?: number[];
+} | {
+    type: 'sweep';
+    cx: CssLengthPct;
+    cy: CssLengthPct;
+    unitAngles?: boolean;
+    colors: string[];
+    locations?: number[];
+} | {
+    type: 'mesh';
+    columns: number;
+    rows: number;
+    smoothsColors?: boolean;
+    points: {
+        x: number;
+        y: number;
+    }[];
+    colors: string[];
+    background?: string;
+    locations?: undefined;
+};
+type WithGradientInterpolation<T> = T extends unknown ? T & {
+    interpolation?: GradientInterpolation;
+} : never;
+export type ParsedGradient = WithGradientInterpolation<GradientShape>;
+export type MeshGradient = Extract<ParsedGradient, {
+    type: 'mesh';
+}>;
+export interface AndroidRipplePaint {
+    width: number;
+    height: number;
+    touchX: number;
+    touchY: number;
+    progress: number;
+    phase: number;
+    density: number;
+    color: string | DynamicColor;
+    alpha: number;
+}
+export interface AndroidSwitchPaint {
+    position: number;
+    checked: boolean;
+    rtl: boolean;
+    density: number;
+    trackColor: string;
+    thumbColor: string;
+}
+export type GradientStyle = ParsedGradient & {
+    startAngle?: number;
+};
+export type ParsedFilterOp = {
+    type: 'brightness';
+    value: number;
+} | {
+    type: 'blur';
+    value: number;
+} | {
+    type: 'contrast';
+    value: number;
+} | {
+    type: 'grayscale';
+    value: number;
+} | {
+    type: 'hue-rotate';
+    value: number;
+} | {
+    type: 'invert';
+    value: number;
+} | {
+    type: 'opacity';
+    value: number;
+} | {
+    type: 'saturate';
+    value: number;
+} | {
+    type: 'sepia';
+    value: number;
+} | {
+    type: 'color-matrix';
+    matrix: number[];
+} | {
+    type: 'color-multiply';
+    color: unknown;
+} | {
+    type: 'luminance-to-alpha';
+} | {
+    type: 'metal-shader-effect';
+    effect: MetalShaderEffectFilter;
+} | {
+    type: 'drop-shadow';
+    offsetX: number;
+    offsetY: number;
+    blurRadius: number;
+    color: string;
+};
+export interface SootSimAnimatedStyleValue {
+    getValue(): unknown;
+}
+type SootSimAnimatedLength = number | string | SootSimAnimatedStyleValue;
+type SootSimAnimatedNumber = number | SootSimAnimatedStyleValue;
+type SootSimAnimatedFilter = string | FilterValue | FilterValue[] | SootSimAnimatedStyleValue;
+export interface SootSimLensFold {
+    lensStrength: number;
+    foldLimit: [number, number];
+    refractionExponent: number;
+    refractionAnisotropy: [number, number];
+    blur: number;
+    intensity: number;
+}
+export interface PeachSdfShape {
+    x: SootSimAnimatedNumber;
+    y: SootSimAnimatedNumber;
+    width: SootSimAnimatedNumber;
+    height: SootSimAnimatedNumber;
+    radius: SootSimAnimatedNumber;
+}
+export interface PeachSdfDisplacement {
+    first: PeachSdfShape;
+    second: PeachSdfShape;
+    height: SootSimAnimatedNumber;
+    amount: SootSimAnimatedNumber;
+    gaussianRadius: SootSimAnimatedNumber;
+}
+type SootSimLiquidGlassStyle = Omit<LiquidGlassConfig, 'cornerRadius' | 'bodyOpacity' | 'blurSigma' | 'vibrancy' | 'merge' | 'interactionIntensity'> & {
+    cornerRadius?: SootSimAnimatedNumber;
+    bodyOpacity?: SootSimAnimatedNumber;
+    blurSigma?: SootSimAnimatedNumber;
+    vibrancy?: SootSimAnimatedNumber;
+    interactionIntensity?: SootSimAnimatedNumber;
+};
+export interface SootSimStyle {
+    _paragraphStyle?: AttributedParagraphStyle;
+    userInterfaceStyle?: 'light' | 'dark';
+    flex?: number;
+    direction?: 'inherit' | 'ltr' | 'rtl';
+    flexDirection?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
+    alignItems?: 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'baseline';
+    alignContent?: 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'space-between' | 'space-around';
+    justifyContent?: 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+    alignSelf?: 'auto' | 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'baseline';
+    flexWrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
+    flexGrow?: number;
+    flexShrink?: number;
+    flexBasis?: number | string;
+    gap?: number;
+    rowGap?: number;
+    columnGap?: number;
+    width?: SootSimAnimatedLength;
+    height?: SootSimAnimatedLength;
+    minWidth?: SootSimAnimatedLength;
+    minHeight?: SootSimAnimatedLength;
+    maxWidth?: SootSimAnimatedLength;
+    maxHeight?: SootSimAnimatedLength;
+    padding?: number;
+    paddingTop?: number;
+    paddingRight?: number;
+    paddingBottom?: number;
+    paddingLeft?: number;
+    paddingHorizontal?: number;
+    paddingVertical?: number;
+    paddingStart?: number;
+    paddingEnd?: number;
+    margin?: SootSimAnimatedLength;
+    marginTop?: SootSimAnimatedLength;
+    marginRight?: SootSimAnimatedLength;
+    marginBottom?: SootSimAnimatedLength;
+    marginLeft?: SootSimAnimatedLength;
+    marginHorizontal?: SootSimAnimatedLength;
+    marginVertical?: SootSimAnimatedLength;
+    marginStart?: SootSimAnimatedLength;
+    marginEnd?: SootSimAnimatedLength;
+    position?: 'relative' | 'absolute' | 'static';
+    top?: SootSimAnimatedLength;
+    right?: SootSimAnimatedLength;
+    bottom?: SootSimAnimatedLength;
+    left?: SootSimAnimatedLength;
+    start?: SootSimAnimatedLength;
+    end?: SootSimAnimatedLength;
+    inset?: SootSimAnimatedLength;
+    backgroundColor?: any;
+    tintColor?: any;
+    borderColor?: string;
+    borderWidth?: number;
+    borderTopWidth?: number;
+    borderBottomWidth?: number;
+    borderLeftWidth?: number;
+    borderRightWidth?: number;
+    borderTopColor?: string;
+    borderBottomColor?: string;
+    borderLeftColor?: string;
+    borderRightColor?: string;
+    borderStyle?: 'solid' | 'dotted' | 'dashed';
+    borderStartWidth?: number;
+    borderEndWidth?: number;
+    borderStartColor?: string;
+    borderEndColor?: string;
+    borderRadius?: SootSimAnimatedNumber;
+    borderTopLeftRadius?: SootSimAnimatedNumber;
+    borderTopRightRadius?: SootSimAnimatedNumber;
+    borderBottomRightRadius?: SootSimAnimatedNumber;
+    borderBottomLeftRadius?: SootSimAnimatedNumber;
+    borderBottomStartRadius?: SootSimAnimatedNumber;
+    borderBottomEndRadius?: SootSimAnimatedNumber;
+    opacity?: any;
+    backfaceVisibility?: 'visible' | 'hidden';
+    strokeDasharray?: any;
+    strokeDashoffset?: any;
+    overflow?: 'visible' | 'hidden' | 'scroll';
+    pointerEvents?: 'auto' | 'none' | 'box-none' | 'box-only';
+    zIndex?: SootSimAnimatedLength;
+    shadowColor?: string;
+    shadowOffset?: {
+        width: number;
+        height: number;
+    };
+    shadowOpacity?: number;
+    shadowRadius?: number;
+    _coreAnimationShadowPath?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        cornerRadius?: number;
+    } | null;
+    boxShadow?: string | BoxShadowValue | BoxShadowValue[] | SootSimAnimatedStyleValue;
+    _boxShadow?: ParsedBoxShadow[];
+    _boxShadowOpacity?: SootSimAnimatedNumber;
+    filter?: SootSimAnimatedFilter;
+    _filter?: ParsedFilterOp[];
+    mixBlendMode?: 'normal' | 'plus-lighter' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity' | 'destination-out';
+    isolation?: 'auto' | 'isolate';
+    outlineWidth?: number;
+    outlineStyle?: 'solid' | 'dashed' | 'dotted';
+    outlineColor?: string;
+    outlineOffset?: number;
+    boxSizing?: 'border-box' | 'content-box';
+    display?: 'flex' | 'none' | 'contents';
+    _contentsPressable?: boolean;
+    _ignoresSuspenseHide?: boolean;
+    color?: string | DynamicColor;
+    fontSize?: number;
+    fontWeight?: string;
+    fontFamily?: string;
+    fontStyle?: 'normal' | 'italic';
+    fontVariant?: string[];
+    fontVariationSettings?: string | Readonly<Record<string, number>>;
+    _caseSensitiveForms?: true;
+    textAlign?: 'left' | 'center' | 'right' | 'justify' | 'start' | 'end' | 'auto';
+    lineHeight?: number;
+    _lineLeading?: number;
+    _lineAscent?: number;
+    _uikitLabel?: true;
+    _textKitLeadingAbove?: true;
+    _coreTextLine?: true;
+    _textBackingRaster?: true;
+    _fieldLine?: boolean;
+    _swiftUIWidthProposal?: number;
+    _minimumScaleFactor?: number;
+    _hyphenationLocale?: string;
+    _hyphenationFactor?: number;
+    _swiftUIText?: true;
+    _composeText?: true;
+    _androidTextView?: true;
+    _androidTextSize?: 'dimension' | 'sp';
+    _swiftUILayout?: true;
+    _swiftUIVerticalGuide?: 'firstTextLineCenter';
+    _swiftUIPlatformView?: true;
+    _uikitControlContent?: true;
+    _numericText?: NumericTextPaintRequest;
+    letterSpacing?: number;
+    textDecorationLine?: 'none' | 'underline' | 'line-through' | 'underline line-through';
+    textDecorationColor?: string;
+    textDecorationStyle?: 'solid' | 'double' | 'dotted' | 'dashed';
+    textTransform?: 'none' | 'uppercase' | 'lowercase' | 'capitalize';
+    textShadowColor?: string;
+    textShadowOffset?: {
+        width: number;
+        height: number;
+    };
+    textShadowRadius?: number;
+    includeFontPadding?: boolean;
+    textAlignVertical?: 'auto' | 'top' | 'bottom' | 'center';
+    writingDirection?: 'auto' | 'ltr' | 'rtl';
+    backgroundImage?: string;
+    experimental_backgroundImage?: string | Array<{
+        type?: string;
+        colorStops?: Array<{
+            color?: string;
+            position?: number | string | {
+                value?: number;
+                unit?: string;
+            };
+        }>;
+        direction?: string | {
+            type?: string;
+            value?: string | number;
+        };
+    }>;
+    _gradient?: GradientStyle | GradientStyle[];
+    experimental_backgroundSize?: string | ReadonlyArray<unknown>;
+    experimental_backgroundPosition?: string | ReadonlyArray<unknown>;
+    experimental_backgroundRepeat?: string | ReadonlyArray<unknown>;
+    _backgroundSize?: BackgroundSizeEntry[];
+    _backgroundPosition?: BackgroundPositionEntry[];
+    _backgroundRepeat?: BackgroundRepeatEntry[];
+    _androidRipple?: AndroidRipplePaint;
+    _androidSwitch?: AndroidSwitchPaint;
+    borderCurve?: 'circular' | 'continuous';
+    _squircle?: boolean;
+    _hitShape?: 'circle' | {
+        kind: 'roundedRectangle' | 'capsule' | 'ellipse';
+        path: string;
+    };
+    _squircleSmoothing?: number;
+    __animated?: boolean;
+    __hasAnimatedValue?: boolean;
+    __animatedDeps?: ReadonlyArray<{
+        _sootsimNativeAnimationId?: number;
+    }>;
+    backdropFilter?: number;
+    _uiBlurMaterial?: UIBlurMaterialStyle;
+    _tenantBlur?: {
+        sigma: number;
+        colorMatrix?: readonly number[];
+    };
+    _backdropSampleInsetX?: number;
+    _backdropSampleClipInset?: true;
+    _liquidGlass?: SootSimLiquidGlassStyle;
+    _sourceLayerProjection?: boolean;
+    _lensFold?: SootSimLensFold | null;
+    _sdfDisplacement?: PeachSdfDisplacement;
+    _liquidGlassRect?: {
+        x: SootSimAnimatedNumber;
+        y: SootSimAnimatedNumber;
+        width: SootSimAnimatedNumber;
+        height: SootSimAnimatedNumber;
+        merge?: {
+            spacing: number;
+            members: ReadonlyArray<{
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+            }>;
+        };
+    } | null;
+    _liquidGlassOpacity?: number | null;
+    _preserveLiquidGlassForeground?: boolean;
+    _liquidGlassMaterialTint?: {
+        light: string;
+        dark: string;
+    };
+    _plusVibrancy?: {
+        darker: string;
+        lighter?: string;
+    } | {
+        darker?: undefined;
+        lighter: string;
+    };
+    _backdropColorMatrix?: readonly number[];
+    _legacyVibrancy?: 'light' | 'dark';
+    _liquidGlassEdge?: LiquidGlassEdgeConfig;
+    _glassContainer?: {
+        spacing: number;
+        transaction?: {
+            id: number;
+            animation: {
+                kind: string;
+                curve?: string;
+                duration?: number;
+                response?: number;
+                dampingFraction?: number;
+                speed?: number;
+                delay?: number;
+            };
+        };
+    };
+    _glassEffectId?: {
+        id: string;
+        namespaceId: string;
+    };
+    transformOrigin?: string | [number | string, number | string, number?];
+    elevation?: number;
+    aspectRatio?: number | string;
+    transform?: Array<Record<string, any>>;
+    _presentationLayerTransform?: boolean;
+    _scrollPresentationOffsetY?: import('./animated.d.ts').AnimatedNumber;
+    _uikitPresentationFrame?: true;
+    _formSheetScaleTransform?: boolean;
+    _layoutOnly?: boolean;
+    _repaintBoundary?: boolean;
+    _wireframeHidden?: boolean;
+    _wireframeWallpaper?: boolean;
+}
+export interface SootSimLayout {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface SootSimTextLayoutLine {
+    ascender: number;
+    capHeight: number;
+    descender: number;
+    height: number;
+    text: string;
+    width: number;
+    x: number;
+    xHeight: number;
+    y: number;
+}
+export interface VirtualSurface {
+    readonly __virtual: true;
+    width(): number;
+    height(): number;
+}
+export type AccessibilityTextConfigurationSource = 'settings' | 'node';
+interface RenderContextBase {
+    canvasKit: CanvasKit;
+    fontMgr: FontMgr;
+    dpr: number;
+    accessibilityTextConfigurationSource?: AccessibilityTextConfigurationSource;
+}
+export interface LayoutContext extends RenderContextBase {
+    kind: 'layout';
+    surface: Surface | VirtualSurface;
+}
+export interface PrewarmPass {
+    requireProgress: boolean;
+    completed: WeakSet<SootSimNode> | null;
+    reachSkips: number;
+    deadlineMs: number;
+    records: number;
+    exhausted: boolean;
+    realize: boolean;
+    realizeChunkReplays: number;
+    rasterPromotions: number;
+    realizeRasterBlits: number;
+    reach: PrewarmReach;
+    paintedNodeIds?: ReadonlySet<number>;
+}
+export interface PrewarmReach {
+    x: number;
+    y: number;
+}
+export type MetalShaderEffectOutput = {
+    readonly image: SkImage | null;
+    readonly pixelsPerPoint: number;
+    readonly origin: readonly [number, number];
+};
+export interface RenderContext extends RenderContextBase {
+    kind: 'paint';
+    windowPresentation?: {
+        width: number;
+        height: number;
+        angle: number;
+    };
+    surface: Surface;
+    canvas: Canvas;
+    webViewFrameOwner?: {
+        surfaceId: string;
+        generation: number;
+    };
+    metalEffectOutputs?: ReadonlyMap<SootSimNode, MetalShaderEffectOutput>;
+    suppressText?: boolean;
+    appMotionEnded?: boolean;
+    appInMotion?: boolean;
+    motionApproximate?: boolean;
+    captureFilterActive?: boolean;
+    screenOverlayLayer?: boolean;
+    textLoupe?: LoupeState;
+    textLoupeMotion?: {
+        values: Float64Array;
+        moving: boolean;
+    };
+    nativeWindowLayers?: readonly NativeWindowPortalLayer[];
+    gpuBacked?: boolean;
+    resolveSurfaceDraws?: () => void;
+    backdropSeeded?: boolean;
+    wireframeMaskedMaterial?: boolean;
+    suppressMaskedLiquidGlass?: boolean;
+    deferSurfaceFlush?: boolean;
+    shouldFlushAfterBasePass?: () => boolean;
+    onAfterBasePass?: () => void;
+    recordingBoundary?: boolean;
+    textVisit?: {
+        node: SootSimNode;
+        reuse: boolean;
+        reached: boolean;
+        failed: boolean;
+    };
+    flatBake?: boolean;
+    flattenedGroup?: SootSimNode;
+    flatAncestor?: boolean;
+    flatDeps?: [boolean];
+    damage?: FrameDamage | null;
+    damageClip?: DamageRect | null;
+    excludedNodeIds?: ReadonlySet<number>;
+    prewarm?: PrewarmPass;
+    recordingFailed?: boolean;
+    zoomCardBackdrops?: ReadonlyMap<SootSimNode, ZoomCardBackdrop>;
+}
+export interface ZoomCardBackdrop {
+    width: number;
+    height: number;
+    radii: {
+        tl: number;
+        tr: number;
+        br: number;
+        bl: number;
+    };
+    backgroundColor: SootSimStyle['backgroundColor'];
+}
+export type MeasureContext = RenderContext | LayoutContext;
+export declare function isVirtualSurface(surface: Surface | VirtualSurface): surface is VirtualSurface;
+export interface TransformRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface SynchronousRasterOptions {
+    width: number | null;
+    height: number | null;
+    scale: number;
+    opaque: boolean;
+}
+export interface SynchronousRaster {
+    width: number;
+    height: number;
+    pixels: Uint8Array;
+}
+export {};

package/dist-types/packages/peach-engine/src/engine/visible-frame.d.ts

@@ -0,0 +1,54 @@
+import { type InspectOcclusionRect } from './inspect-visibility.d.ts';
+import { type SootSimNode, type NodeGeometryQuery } from './node.d.ts';
+import type { SootSimVisibleFrame } from '../../../peach-globals/src/index.d.ts';
+export declare function isInspectPortalNode(node: SootSimNode): boolean;
+export declare function inspectZIndex(node: SootSimNode): number;
+export declare function getInspectPortalsBackToFront(root: SootSimNode): SootSimNode[];
+export type VisibleFrame = SootSimVisibleFrame;
+export declare function isInBackgroundVisibleInspectModal(node: SootSimNode, query: VisibleFrameQuery): boolean;
+export interface VisibleFrameQuery {
+    geometry: NodeGeometryQuery;
+    accessibilityModalSiblings?: Map<SootSimNode, SootSimNode[]>;
+    styles: Map<SootSimNode, Record<string, unknown>>;
+    presentationRects: Map<SootSimNode, InspectOcclusionRect | null>;
+    portals: Map<SootSimNode, SootSimNode[]>;
+    hiddenChains: Map<SootSimNode, SootSimNode | null>;
+    backgroundVisibleModalChains: Map<SootSimNode, boolean>;
+    paintedRects: Map<SootSimNode, InspectOcclusionRect>;
+    visibleFrames: Map<SootSimNode, VisibleFrame & {
+        area: number;
+    }>;
+    childClips: Map<SootSimNode, ClipBounds>;
+    occluderBounds: Map<SootSimNode, InspectOcclusionRect | null>;
+    seeThroughModals?: boolean;
+}
+type ClipBounds = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    leftBy: SootSimNode | null;
+    topBy: SootSimNode | null;
+    rightBy: SootSimNode | null;
+    bottomBy: SootSimNode | null;
+};
+export declare function createVisibleFrameQuery(): VisibleFrameQuery;
+export interface VisibleFrameOptions {
+    ignorePresentationLayerTransforms?: boolean;
+    query?: VisibleFrameQuery;
+    explain?: boolean;
+}
+export declare function nodeClipsDescendants(node: SootSimNode): boolean;
+export declare function inspectPaintChildren(node: SootSimNode): import("./node.d.ts").SootSimChild[];
+export declare function getNodeVisibleFrame(node: SootSimNode, abs: {
+    x: number;
+    y: number;
+}, inlineBounds: {
+    width: number;
+    height: number;
+} | null, options?: VisibleFrameOptions): VisibleFrame & {
+    area: number;
+};
+export declare function getNodeVisibleInspectFrame(node: SootSimNode, query?: VisibleFrameQuery): VisibleFrame;
+export declare function visibleFrameContainsPoint(frame: InspectOcclusionRect, x: number, y: number): boolean;
+export {};