import { EUseWasmSimd } from "../../types/EUseWasmSimd";
import { EUseWasm64 } from "../../types/EUseWasm64";
import { EWatermarkPosition } from "../../types/WatermarkPosition";
import type { ISciChartLoader } from "./loader";
export declare class SciChartDefaults {
    /**
     * Set this true to allow reuse of label textures across different axes and different charts
     */
    static useSharedCache: boolean;
    /**
     * NOT RECOMMENDED UNLESS IN DEBUG MODE: Turn on/off adaptive, visually lossless resampling algorithms
     * globally for the entire application.
     *
     * To do this on a per-series basis use {@link BaseRenderableSeries.resamplingMode}. For precision issues try
     * adjusting the {@link BaseRenderableSeries.resamplingPrecision} property
     */
    static debugDisableResampling: boolean;
    /**
     * Turn on/off warnings to optimize performance
     */
    static performanceWarnings: boolean;
    /**
     * Whether the engine's per-frame GPU timing is enabled on WebGPU. Default false.
     *
     * When true, the `timestamp-query` device feature is requested at WebGPU device creation (if the adapter
     * offers it) and the engine timestamps every render pass, resolves the query set and reads it back on every
     * frame, which is what feeds {@link SciChartSurfaceBase.frameTimed} on WebGPU. When false, no timestamp
     * query is ever encoded and `frameTimed` never fires on WebGPU.
     *
     * Off by default because the resolve is not free: on Apple GPUs (M2 and later) the browser serialises the GPU
     * around every timestamp resolve, which measured as +7% per frame on a 1500-series chart and up to a whole
     * frame when the GPU is busy. WebGL timing is not affected by this setting.
     *
     * Must be set before the first WebGPU surface is created: a device feature cannot be added to an existing
     * device, so changing this afterwards has no effect for the rest of the session.
     */
    static enableGpuTimers: boolean;
    /**
     * Default of {@link SciChartSurfaceBase.suppressDetachedRootWarning} for newly created surfaces.
     * Note this and {@link suppressRepeatedDeleteWarning} apply to every surface on the page - wrappers should prefer
     * the per-surface {@link SciChartSurfaceBase.isLifecycleManagedExternally}.
     */
    static suppressDetachedRootWarning: boolean;
    /**
     * Default of {@link SciChartSurfaceBase.suppressRepeatedDeleteWarning} for newly created surfaces
     */
    static suppressRepeatedDeleteWarning: boolean;
    /**
     * Whether to use WebGL for rendering axis labels.  Default true (was false before v4).
     * These are much faster than rendering using canvas text, but do not have quite the same font and style support.
     *
     * You can set useNativeText on an individual axis using to override this setting.
     */
    static useNativeText: boolean;
    /**
     * Time in ms to retry loading a native font.  If you need to load a large font over a potentially slow connection await sciChartSurface.registerFont
     */
    static nativeFontTimeout: number;
    /**
     * The default position of the watermark for trials
     */
    static watermarkPosition: EWatermarkPosition;
    /** For 2D charts the watermark is normally positioned within the series area.  Set this true to place it relative to the overall canvas.   */
    static watermarkRelativeToCanvas: boolean;
    /**
     * Allows you to customize the loading elements or animation as part of the HTML page / DOM when a {@link SciChartSurface}
     * or {@link SciChart3DSurface} is loading WebAssembly.
     *
     * Set to false for disabling.
     */
    static defaultLoader: false | ISciChartLoader;
    /**
     * Optional - the option of disabling / enabling scaling of the {@link SciChartSurfaceBase}.
     * If false - the {@link SciChartSurfaceBase} will take the height and width of parent div without scaling.
     */
    static disableAspect: boolean;
    /**
     * For 2D charts a number of buffers are created to process data. Buffer size by default grows with usage and caps out at 8,192kb.
     * A total of 10 buffers are created for different scenarios.
     * When SciChartSurface.create() is used this results in a maximum of 80MB memory as a static overhead for the application.
     * When SciChartSurface.createSingle() is used this results in up to 80MB memory *per chart* as a static overhead.
     * Lowering this number to 2048kb (or 1024kb) will reduce memory usage for the SciChart 2D Engine but may impact chart drawing performance.
     * @remarks This property needs to be set before charts created and cannot be dynamically adjusted after that.
     * Do not set lower than 1024kb or higher than 32MB (1024 x 32). Values outside this range will be clamped
     */
    static wasmBufferSizesKb: number;
    /**
     * Defines if newly created charts should be rendered as soon as possible after initialization.
     * Setting to `true` will require surfaces to be "resumed" in order to perform actual rendering.
     */
    static createSuspended: boolean;
    /**
     * Defines how WebAssembly SIMD should be used by SciChart.
     *
     * - Always: Always use SIMD-enabled binaries (you must serve scichart.wasm)
     * - Never: Never use SIMD, always use fallback binaries (you must serve scichart-nosimd.wasm)
     * - Auto: Automatically detect SIMD support and choose appropriate binary (you must serve both variants)
     *
     * @see {@link FeatureDetectionHelper} for SIMD detection utilities
     * @see {@link EUseWasmSimd} for enum values
     */
    static useWasmSimd: EUseWasmSimd;
    /**
     * Defines whether SciChart should use the WebAssembly Memory64 (wasm64) engine variant.
     *
     * wasm64 lifts the wasm32 4GB heap limit but is supported by fewer browsers (Chrome 133+, Firefox 134+,
     * not Safari as of 2025) and is slower per-operation due to 64-bit pointers. It is therefore opt-in
     * (default {@link EUseWasm64.Never}) and always falls back to the standard wasm32 binaries.
     *
     * The wasm64 binary is built with SIMD, so it is only ever served when both Memory64 and SIMD are supported.
     *
     * Union (one-wasm) build: a single binary serves both 2D and 3D, so there is no separate 3D
     * file to deploy - the whole matrix is scichart.wasm, scichart-nosimd.wasm and scichart-64.wasm.
     *
     * - Never: Always use the standard wasm32 binaries (default).
     * - Auto: Use wasm64 when supported (both Memory64 + SIMD), otherwise fall back. You must serve
     *   scichart-64.wasm alongside the standard binaries.
     * - Always: Always use the wasm64 binary. You must serve scichart-64.wasm.
     *
     * In both cases only the .wasm binary is served; the wasm64 loader JS ships inside the
     * scichart package and is bundled with your app.
     *
     * @see {@link FeatureDetectionHelper.supportsWasm64} for the detection utility
     * @see {@link EUseWasm64} for enum values
     */
    static useWasm64: EUseWasm64;
    /**
     * Defines the Default font name. If the font set to this value if will pick the nativeFontFamily or canvasFontFamily
     */
    static autoFontName: string;
    /**
     * Defines Native text font family for Default font name. The default font family loads Arimo Regular font.
     */
    static nativeFontFamily: string;
    /**
     * Defines Canvas text font family for Default font name
     */
    static canvasFontFamily: string;
    /**
     * From v5.0 updates to svg annotations will not trigger a redraw of the whole chart.
     * Set this to true to revert to the old behaviour.  You can also set this per annotation using annotation.reDrawChartOnChange
     */
    static alwaysRedrawFullChartOnSvgChange: boolean;
}