scichart/types/TSciChart.d.ts

Fast WebGL JavaScript Charting Library and Framework

export declare type TSciChart = {
    canvas: HTMLCanvasElement;
    canvas2D: HTMLCanvasElement;
    SCRTFillTextureFloat32: (texture: TSRTexture, width: number, height: number, pixels: SCRTFloatVector) => TSRVector4;
    SCRTMultiplyColorVectorOpacity: (originalVector: IntVector, resultVector: IntVector, factor: number) => void;
    SCRTSetMainWindowSize: (width: number, height: number) => void;
    SCRTDoLeakCheck: () => void;
    SCRTCreateBitmapTexture: (width: number, height: number, textureFormat: eTSRTextureFormat) => TSRTexture;
    SCRTSetTextureLinearSamplerEnabled: (texture: TSRTexture, enabled: boolean) => void;
    SCRTFillTextureAbgr: (texture: TSRTexture, width: number, height: number, pixels: IntVector) => void;
    SCRTSetActiveTexture: (texture: TSRTexture) => void;
    SCRTCreatePalette: (colors: IntVector) => SCRTPalette;
    SCRTFillVectorSequential: (SCRTFillVectorSequential: SCRTDoubleVector, count: number) => void;
    SCRTMemMove: (destPtr: number, sourcePtr: number, count: number) => void;
    SCRTMemCopy: (destPtr: number, sourcePtr: number, count: number) => void;
    SCRTInitEngine2D: () => void;
    SCRTShutdownEngine2D: () => void;
    TSRRequestExit: () => void;
    TSRRequestDraw: () => void;
    TSRRequestCanvasDraw: (canvasID: string) => void;
    TSRSetDrawRequestsEnabled: (enabled: boolean) => void;
    SCRTGetMainRenderContext2D: () => SCRTRenderContext;
    SCRTGetScreenWidth: () => number;
    SCRTGetScreenHeight: () => number;
    SCRTSetWaterMarkProperties: (properties: SCRTWaterMarkProperties) => void;
    SCRTSplineHelperCubicSpline: (xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xsValues: SCRTDoubleVector, ysValues: SCRTDoubleVector, initialSize: number, interpolationPoints: number, containsNAN: boolean) => void;
    SCRTAnimationHelperWave: (yValues: SCRTDoubleVector, durationFraction: number, zeroLine: number, progress: number, ysValues: SCRTDoubleVector) => number;
    SCRTAnimationHelperSweep: (yValues: SCRTDoubleVector, progress: number, ysValues: SCRTDoubleVector) => number;
    SCRTAnimationHelperScale: (yValues: SCRTDoubleVector, zeroLine: number, progress: number, ysValues: SCRTDoubleVector) => number;
    SCRTAnimationHelperFade: (yValues: SCRTDoubleVector, progress: number, ysValues: SCRTDoubleVector) => number;
    SCRTInterpolatePolarLine: (inParams: SCRTPolarInterpolationParams, outParams: SCRTPolarInterpolationParams, radialCoordinateCalculator: CoordinateCalculator, angularRange: number, totalPoints: number, closeNaNGaps: boolean) => void;
    SCRTInterpolatePolarBand: (inParams: SCRTPolarInterpolationParams, outParams: SCRTPolarInterpolationParams, radialCoordinateCalculator: CoordinateCalculator, angularRange: number, totalPoints: number, closeNaNGaps: boolean) => void;
    SCRTSetGlobalSampleChartInterface: (param0: SCRTSampleChartInterface) => void;
    SCRTGetGlobalSampleChartInterface: () => SCRTSampleChartInterface;
    SCRTSetGlobalCopyToDestinationInterface: (param0: SCRTCopyToDestinationInterface) => void;
    SCRTSetClearAlphaParams: (enabled: boolean, alpha: number) => void;
    SCRTRegisterFile: (fileName: string, url: string, callback: SCRTFileLoadCallbackInterface) => void;
    GetMallinfoStats: () => MallinfoStats;
    TSRVector4: (new () => TSRVector4) & (new (x: number, y: number, z: number, w: number) => TSRVector4);
    IntVector: new () => IntVector;
    UIntVector: new () => UIntVector;
    SCRTFloatVector: new () => SCRTFloatVector;
    FloatVector: new () => FloatVector;
    SCRTDoubleVector: (new () => SCRTDoubleVector) & (new (capacity: number) => SCRTDoubleVector);
    DoubleVector: new () => DoubleVector;
    SCRTFifoVector: new (fifoCapacity: number) => SCRTFifoVector;
    SCRTUintVector: new () => SCRTUintVector;
    eTSRTextureFormat: {
        TSR_TEXTUREFORMAT_A8B8G8R8: eTSRTextureFormat;
        TSR_TEXTUREFORMAT_R32F: eTSRTextureFormat;
    };
    ResamplingMode: {
        None: ResamplingMode;
        MinMax: ResamplingMode;
        Min: ResamplingMode;
        Max: ResamplingMode;
        Mid: ResamplingMode;
        MinOrMax: ResamplingMode;
        Auto: ResamplingMode;
    };
    ResamplingData: {
        LinearData: ResamplingData;
        CategoryData: ResamplingData;
        UnevenlySpacedData: ResamplingData;
        UnsortedData: ResamplingData;
    };
    SCRTDoubleResamplerMergeIndicesParams: new () => SCRTDoubleResamplerMergeIndicesParams;
    SCRTPalette: (new () => SCRTPalette) & {
        GetNoOverrideColorCode: () => number;
    };
    ResamplingArgs: new () => ResamplingArgs;
    SCRTXvaluesProvider: new () => SCRTXvaluesProvider;
    SCRTDoubleArraysXyResampleOutput: new () => SCRTDoubleArraysXyResampleOutput;
    SCRTDoubleResampler: new () => SCRTDoubleResampler;
    StringVector: new () => StringVector;
    LinearCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => LinearCoordinateCalculatorDouble;
    FlippedLinearCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => FlippedLinearCoordinateCalculatorDouble;
    LinearCoordinateCalculatorSingle: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => LinearCoordinateCalculatorSingle;
    FlippedLinearCoordinateCalculatorSingle: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => FlippedLinearCoordinateCalculatorSingle;
    CategoryCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number, IndexMin: number, IndexMax: number) => CategoryCoordinateCalculatorDouble;
    FlippedCategoryCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number, IndexMin: number, IndexMax: number) => FlippedCategoryCoordinateCalculatorDouble;
    LogarithmicCoordinateCalculator: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number, LogBase: number) => LogarithmicCoordinateCalculator;
    FlippedLogarithmicCoordinateCalculator: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number, LogBase: number) => FlippedLogarithmicCoordinateCalculator;
    IndexCalculator: new () => IndexCalculator;
    IndexCalculatorParams: new () => IndexCalculatorParams;
    IndexCoordinateCalculator: new (indexCalculatorParams: IndexCalculatorParams) => IndexCoordinateCalculator;
    FlippedIndexCoordinateCalculator: new (indexCalculatorParams: IndexCalculatorParams) => FlippedIndexCoordinateCalculator;
    TSRVector2: (new () => TSRVector2) & (new (x: number, y: number) => TSRVector2);
    SCRTPolarCoordinateTransform: new (XCenter: number, YCenter: number, StartAngle: number) => SCRTPolarCoordinateTransform;
    SCRTFrameRenderer2D: new () => SCRTFrameRenderer2D;
    SCRTDrawLinesParams: new () => SCRTDrawLinesParams;
    SCRTColorVertex: (new () => SCRTColorVertex) & (new (x: number, y: number) => SCRTColorVertex);
    VectorColorVertex: new () => VectorColorVertex;
    SCRTPen: new (penDesc: SCRTPenDescriptor) => SCRTPen;
    SCRTTextureBrush: new (texture: TSRTexture, mappingMode: eSCRTBrushMappingMode, opacity: number) => SCRTTextureBrush;
    SCRTLineType: {
        List: SCRTLineType;
        Strip: SCRTLineType;
        Digital: SCRTLineType;
        Nan: SCRTLineType;
    };
    SCRTPrimitivesEffect: {
        Triangles: SCRTPrimitivesEffect;
        BlurredTriangles: SCRTPrimitivesEffect;
        Heatmap: SCRTPrimitivesEffect;
        Contours: SCRTPrimitivesEffect;
    };
    SCRTDrawPrimitivesParams: new () => SCRTDrawPrimitivesParams;
    SCRTColorTextureVertex: (new () => SCRTColorTextureVertex) & (new (x: number, y: number) => SCRTColorTextureVertex);
    VectorColorTextureVertex: new () => VectorColorTextureVertex;
    SCRTBrush: new () => SCRTBrush;
    SCRTContourParams: new () => SCRTContourParams;
    SCRTDrawRectsParams: new () => SCRTDrawRectsParams;
    SCRTRectVertex: (new () => SCRTRectVertex) & (new (left: number, top: number, right: number, bottom: number) => SCRTRectVertex);
    VectorRectVertex: new () => VectorRectVertex;
    SCRTDrawArcsParams: new () => SCRTDrawArcsParams;
    SCRTArcVertex: new () => SCRTArcVertex;
    VectorArcVertex: new () => VectorArcVertex;
    SCRTLineGapMode: {
        Default: SCRTLineGapMode;
        DrawGaps: SCRTLineGapMode;
        CloseGaps: SCRTLineGapMode;
    };
    SCRTTriangleDrawMode: {
        List: SCRTTriangleDrawMode;
        Polygon: SCRTTriangleDrawMode;
        Strip: SCRTTriangleDrawMode;
    };
    SCRTDrawingParams: new () => SCRTDrawingParams;
    SCRTLineDrawingParams: new () => SCRTLineDrawingParams;
    SCRTLineSeriesDrawingProvider: new () => SCRTLineSeriesDrawingProvider;
    SCRTSmearSeriesParams: new () => SCRTSmearSeriesParams;
    SCRTHeightColorSettings: new () => SCRTHeightColorSettings;
    SCRTSmearSeriesDrawingProvider: new () => SCRTSmearSeriesDrawingProvider;
    SCRTHeightSeriesParams: new () => SCRTHeightSeriesParams;
    TSRVector3: (new () => TSRVector3) & (new (x: number, y: number, z: number) => TSRVector3);
    SCRTHeightSeriesDrawingProvider: new () => SCRTHeightSeriesDrawingProvider;
    SCRTLineSegmentDrawingProvider: new () => SCRTLineSegmentDrawingProvider;
    SCRTHeatmapDrawingParams: new () => SCRTHeatmapDrawingParams;
    SCRTHeatmapSeriesDrawingProvider: new () => SCRTHeatmapSeriesDrawingProvider;
    SCRTPointDrawingParams: new () => SCRTPointDrawingParams;
    SCRTScatterSeriesDrawingProvider: new () => SCRTScatterSeriesDrawingProvider;
    SCRTOhlcDrawingParams: new () => SCRTOhlcDrawingParams;
    SCRTCandlestickSeriesDrawingProvider: new () => SCRTCandlestickSeriesDrawingProvider;
    SCRTMountainDrawingParams: new () => SCRTMountainDrawingParams;
    SCRTBandDrawingParams: new () => SCRTBandDrawingParams;
    SCRTMountainSeriesDrawingProvider: new () => SCRTMountainSeriesDrawingProvider;
    SCRTBandSeriesDrawingProvider: new () => SCRTBandSeriesDrawingProvider;
    SCRTColumnDrawingParams: new () => SCRTColumnDrawingParams;
    SCRTStackedColumnSeriesDrawingProvider: new () => SCRTStackedColumnSeriesDrawingProvider;
    SCRTStackedColumnDrawingParams: new () => SCRTStackedColumnDrawingParams;
    SCRTTriangleSeriesDrawingProvider: new () => SCRTTriangleSeriesDrawingProvider;
    SCRTTriangleDrawingParams: new () => SCRTTriangleDrawingParams;
    SCRTColumnXMode: {
        ColumnXMode_Mid: SCRTColumnXMode;
        ColumnXMode_MidX2Width: SCRTColumnXMode;
        ColumnXMode_Start: SCRTColumnXMode;
        ColumnXMode_StartX2Width: SCRTColumnXMode;
        ColumnXMode_StartX2End: SCRTColumnXMode;
        ColumnXMode_Width: SCRTColumnXMode;
    };
    SCRTColumnYMode: {
        ColumnYMode_CenterHeight: SCRTColumnYMode;
        ColumnYMode_TopBottom: SCRTColumnYMode;
        ColumnYMode_TopHeight: SCRTColumnYMode;
    };
    SCRTRectangleDrawingParams: new () => SCRTRectangleDrawingParams;
    SCRTPolarColumnDrawingParams: new () => SCRTPolarColumnDrawingParams;
    SCRTPolarBandDrawingParams: new () => SCRTPolarBandDrawingParams;
    SCRTSeriesEffectType: {
        Glow: SCRTSeriesEffectType;
    };
    SCRTGlowEffect: new () => SCRTGlowEffect;
    SCRTShadowEffect: new () => SCRTShadowEffect;
    SCRTColumnSeriesDrawingProvider: new () => SCRTColumnSeriesDrawingProvider;
    SCRTBubbleSeriesDrawingProvider: new () => SCRTBubbleSeriesDrawingProvider;
    SCRTRectangleSeriesDrawingProvider: new () => SCRTRectangleSeriesDrawingProvider;
    SCRTPolarColumnSeriesDrawingProvider: new () => SCRTPolarColumnSeriesDrawingProvider;
    SCRTPolarBandSeriesDrawingProvider: new () => SCRTPolarBandSeriesDrawingProvider;
    SCRTSpriteType: {
        Normal: SCRTSpriteType;
        FixedSize: SCRTSpriteType;
    };
    SCRTCandleType: {
        CandleStick: SCRTCandleType;
        OHLC: SCRTCandleType;
    };
    SCRTPenDescriptor: new () => SCRTPenDescriptor;
    SCRTSolidBrush: new (color: number, transparent: boolean) => SCRTSolidBrush;
    eSCRTBrushMappingMode: {
        PerPrimitive: eSCRTBrushMappingMode;
        PerScreen: eSCRTBrushMappingMode;
    };
    SCRTTextureBrushSamplerMode: {
        Linear: SCRTTextureBrushSamplerMode;
        Point: SCRTTextureBrushSamplerMode;
        Wrap: SCRTTextureBrushSamplerMode;
    };
    eSCRTBlendMode: {
        BlendDisabled: eSCRTBlendMode;
        BlendDefault: eSCRTBlendMode;
        BlendAdditiveColor: eSCRTBlendMode;
        BlendAdditiveAlpha: eSCRTBlendMode;
        BlendAdditiveOneAlpha: eSCRTBlendMode;
    };
    SCRTFontKey: new (name: string, size: number, transformed: boolean, advanced: boolean) => SCRTFontKey;
    WStringVector: new () => WStringVector;
    SCRTArcParams: new () => SCRTArcParams;
    SCRTDoubleRange: (new () => SCRTDoubleRange) & (new (min: number, max: number) => SCRTDoubleRange);
    SCRTFindIndexSearchMode: {
        Exact: SCRTFindIndexSearchMode;
        Nearest: SCRTFindIndexSearchMode;
        RoundDown: SCRTFindIndexSearchMode;
        RoundUp: SCRTFindIndexSearchMode;
    };
    NumberUtil: {
        Log: (value: number, logBase: number) => number;
        IsPowerOf: (value: number, power: number, logBase: number) => boolean;
        RoundUpPower: (value: number, power: number, logBase: number) => number;
        RoundDownPower: (value: number, power: number, logBase: number) => number;
        RoundUp: (value: number, nearest: number) => number;
        RoundDown: (value: number, nearest: number) => number;
        IsDivisibleBy: (value: number, divisor: number) => boolean;
        Constrain: (value: number, lowerBound: number, upperBound: number) => number;
        RoundToDigits: (value: number, decimals: number) => number;
        MinMax: (inputValues: SCRTDoubleVector, containsNaN: boolean) => SCRTDoubleRange;
        MinMaxWithIndex: (inputValues: SCRTDoubleVector, startIndex: number, count: number, containsNaN: boolean) => SCRTDoubleRange;
        MinMaxPair: (inputValues1: SCRTDoubleVector, inputValues2: SCRTDoubleVector, mult: number, multInv: number, containsNaN: boolean) => SCRTDoubleRange;
        MinMaxPairWithIndex: (inputValues1: SCRTDoubleVector, inputValues2: SCRTDoubleVector, mult: number, multInv: number, startIndex: number, count: number, containsNaN: boolean) => SCRTDoubleRange;
        FindIndex: (inputValues: SCRTDoubleVector, value: number, searchMode: SCRTFindIndexSearchMode, dataIsSortedAscending: boolean) => number;
        LinearInterpolateI: (from: number, to: number, ratio: number) => number;
    };
    SCRTHitTestHelper: {
        GetNearestXyPoint: (xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, isSorted: boolean, xHitCoord: number, yHitCoord: number, hitTestRadius: number) => SCRTDoubleRange;
        GetNearestPolarXyPoint: (xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xHitCoord: number, yHitCoord: number, xDirectionOnly: boolean, isSorted: boolean) => SCRTDoubleRange;
        GetNearestTriangle: (isPolygon: boolean, polygonVertices: number, xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xHitCoord: number, yHitCoord: number) => SCRTDoubleRange;
    };
    NiceDoubleScale: {
        CalculateTickSpacing: (min: number, max: number, minorsPerMajor: number, maxTicks: number) => SCRTDoubleRange;
        NiceNum: (range: number, round: boolean) => number;
    };
    NiceLogScale: {
        CalculateTickSpacing: (min: number, max: number, logBase: number, minorsPerMajor: number, maxTicks: number) => SCRTDoubleRange;
        CalculateLowPrecisionTickSpacing: (min: number, max: number, logBase: number, minorsPerMajor: number, maxTicks: number) => SCRTDoubleRange;
    };
    SCRTLicenseType: {
        LICENSE_TYPE_NO_LICENSE: SCRTLicenseType;
        LICENSE_TYPE_TRIAL: SCRTLicenseType;
        LICENSE_TYPE_COMMUNITY: SCRTLicenseType;
        LICENSE_TYPE_FULL: SCRTLicenseType;
        LICENSE_TYPE_FULL_EXPIRED: SCRTLicenseType;
        LICENSE_TYPE_TRIAL_EXPIRED: SCRTLicenseType;
        LICENSE_TYPE_SUBSCRIPTION_EXPIRED: SCRTLicenseType;
        LICENSE_TYPE_INVALID_DEVELOPER_LICENSE: SCRTLicenseType;
        LICENSE_TYPE_REQUIRES_VALIDATION: SCRTLicenseType;
        LICENSE_TYPE_INVALID_LICENSE: SCRTLicenseType;
    };
    SCRTCredentials: {
        SetRuntimeLicenseKeyW: (licenseKey: string) => boolean;
        GetLicenseType: () => SCRTLicenseType;
        ResetRuntimeLicense: () => void;
        HasFeature: (feature: string) => SCRTLicenseType;
        GetLicenseDaysRemaining: () => number;
        GetExpiryDate: () => string;
        Dump: () => string;
        GetEncrypted: (stringToEncrypt: string) => string;
        Hash256Encode64: (stringToHash: string) => string;
        GetOrderId: () => string;
        GetAllowDebugging: () => boolean;
        GetLicenseErrors: () => string;
        GetLicenseChallenge: () => string;
        ApplyLicenseResponse: (response: string) => number;
        RequiresValidation: () => boolean;
        GetBuildStamp: () => string;
        GetProductCode: () => string;
        GetEncryptedOrderId: () => string;
        GetDeveloperCount: () => number;
    };
    SCRTWaterMarkProperties: new () => SCRTWaterMarkProperties;
    SCRTPolarInterpolationParams: new () => SCRTPolarInterpolationParams;
    eTSRPlatform: {
        Undefined: eTSRPlatform;
        Windows: eTSRPlatform;
        Mac: eTSRPlatform;
        Linux: eTSRPlatform;
        Android: eTSRPlatform;
        iOS: eTSRPlatform;
        Web: eTSRPlatform;
    };
    eVariableUsage: {
        Normal: eVariableUsage;
        Pointer: eVariableUsage;
        Vector: eVariableUsage;
        VectorOfPointers: eVariableUsage;
        Blob: eVariableUsage;
        Array: eVariableUsage;
        DynamicArray: eVariableUsage;
    };
    eTSRMetaDataType: {
        Unknown: eTSRMetaDataType;
        Core: eTSRMetaDataType;
        Defined: eTSRMetaDataType;
        DynamicDefined: eTSRMetaDataType;
        Enum: eTSRMetaDataType;
        BitFlags: eTSRMetaDataType;
    };
    eTSRRendererType: {
        TSR_RENDERER_TYPE_UNDEFINED: eTSRRendererType;
        TSR_RENDERER_TYPE_D3D11: eTSRRendererType;
        TSR_RENDERER_TYPE_D3D11_LEVEL10: eTSRRendererType;
        TSR_RENDERER_TYPE_D3D9: eTSRRendererType;
        TSR_RENDERER_TYPE_GL: eTSRRendererType;
        TSR_RENDERER_TYPE_GLES2: eTSRRendererType;
        TSR_RENDERER_TYPE_GLES3: eTSRRendererType;
        TSR_RENDERER_TYPE_METAL: eTSRRendererType;
        TSR_RENDERER_TYPE_VULKAN: eTSRRendererType;
        TSR_RENDERER_TYPE_D3D12: eTSRRendererType;
    };
    eTSRCameraProjectionMode: {
        CAMERA_PROJECTIONMODE_PERSPECTIVE: eTSRCameraProjectionMode;
        CAMERA_PROJECTIONMODE_ORTHOGONAL: eTSRCameraProjectionMode;
    };
    TSRCamera: new () => TSRCamera;
    SCRTSampleChartInterface: {
        implement: (wrapper: SCRTSampleChartInterfaceWrapper) => SCRTSampleChartInterface;
    };
    SCRTCopyToDestinationInterface: {
        implement: (wrapper: SCRTCopyToDestinationInterfaceWrapper) => SCRTCopyToDestinationInterface;
    };
    SCRTFileLoadCallbackInterface: {
        implement: (wrapper: SCRTFileLoadCallbackInterfaceWrapper) => SCRTFileLoadCallbackInterface;
    };
    SCRTSurfaceDestination: {
        implement: (wrapper: SCRTSurfaceDestinationWrapper) => SCRTSurfaceDestination;
    };
    eTSRTextAlignMode: {
        Left: eTSRTextAlignMode;
        Center: eTSRTextAlignMode;
        Right: eTSRTextAlignMode;
    };
    TSRTextLineBounds: new () => TSRTextLineBounds;
    TSRTextBounds: new () => TSRTextBounds;
};
export declare class TSRVector4 {
    Assign(x: number, y: number, z: number, w: number): void;
    x: number;
    y: number;
    z: number;
    w: number;
    delete(): void;
}
export declare class TSRTexture {
    GetWidth(): number;
    GetHeight(): number;
    delete(): void;
}
export declare class IntVector {
    dataPtr(offset: number): number;
    push_back(element: number): void;
    pop_back(): void;
    size(): number;
    resize(size: number, initialValue: number): void;
    reserve(size: number): void;
    clear(): void;
    fill(element: number): void;
    insertAt(index: number, element: number): void;
    removeAt(index: number): void;
    removeRange(index: number, count: number): void;
    delete(): void;
    set(index: number, element: number): void;
    get(index: number): number;
}
export declare class UIntVector {
    dataPtr(offset: number): number;
    push_back(element: number): void;
    pop_back(): void;
    size(): number;
    resize(size: number, initialValue: number): void;
    reserve(size: number): void;
    clear(): void;
    fill(element: number): void;
    insertAt(index: number, element: number): void;
    removeAt(index: number): void;
    removeRange(index: number, count: number): void;
    delete(): void;
    set(index: number, element: number): void;
    get(index: number): number;
}
export declare class SCRTFloatVector {
    push_back(_dNewValue: number): void;
    resize(_iNewSize: number, _dInitialValue: number): void;
    resizeFast(_iNewSize: number): void;
    reserve(_iCount: number): void;
    clear(): void;
    size(): number;
    capacity(): number;
    get(_iIndex: number): number;
    set(_iIndex: number, _dValue: number): void;
    insertAt(_iIndex: number, _dValue: number): void;
    removeAt(_iIndex: number): void;
    removeRange(_iIndex: number, _iCount: number): void;
    dataPtr(_iOffset: number): number;
    delete(): void;
}
export declare class FloatVector {
    dataPtr(offset: number): number;
    push_back(element: number): void;
    pop_back(): void;
    size(): number;
    resize(size: number, initialValue: number): void;
    reserve(size: number): void;
    clear(): void;
    fill(element: number): void;
    insertAt(index: number, element: number): void;
    removeAt(index: number): void;
    removeRange(index: number, count: number): void;
    delete(): void;
    set(index: number, element: number): void;
    get(index: number): number;
}
export declare class SCRTDoubleVector {
    push_back(_dNewValue: number): void;
    resize(_iNewSize: number, _dInitialValue: number): void;
    resizeFast(_iNewSize: number): void;
    reserve(_iCount: number): void;
    clear(): void;
    size(): number;
    capacity(): number;
    get(_iIndex: number): number;
    set(_iIndex: number, _dValue: number): void;
    insertAt(_iIndex: number, _dValue: number): void;
    removeAt(_iIndex: number): void;
    removeRange(_iIndex: number, _iCount: number): void;
    dataPtr(_iOffset: number): number;
    delete(): void;
}
export declare class DoubleVector {
    dataPtr(offset: number): number;
    push_back(element: number): void;
    pop_back(): void;
    size(): number;
    resize(size: number, initialValue: number): void;
    reserve(size: number): void;
    clear(): void;
    fill(element: number): void;
    insertAt(index: number, element: number): void;
    removeAt(index: number): void;
    removeRange(index: number, count: number): void;
    delete(): void;
    set(index: number, element: number): void;
    get(index: number): number;
}
export declare class SCRTFifoVector extends SCRTDoubleVector {
    dataPtrZero(): number;
    notifyAppend(_iCount: number): void;
    getRaw(_iIndex: number): number;
    getStartIndex(): number;
    delete(): void;
}
export declare class SCRTUintVector {
    push_back(_dNewValue: number): void;
    resize(_iNewSize: number, _dInitialValue: number): void;
    resizeFast(_iNewSize: number): void;
    reserve(_iCount: number): void;
    clear(): void;
    size(): number;
    capacity(): number;
    get(_iIndex: number): number;
    set(_iIndex: number, _dValue: number): void;
    insertAt(_iIndex: number, _dValue: number): void;
    removeAt(_iIndex: number): void;
    removeRange(_iIndex: number, _iCount: number): void;
    dataPtr(_iOffset: number): number;
    delete(): void;
}
export declare class eTSRTextureFormat {
}
export declare class ResamplingMode {
}
export declare class ResamplingData {
}
/**
 *WebAssembly / Native params for MergeIndices method
 */
export declare class SCRTDoubleResamplerMergeIndicesParams {
    SetXInput(xInput: SCRTDoubleVector): void;
    SetYInput(yInput: SCRTDoubleVector): void;
    SetY1Input(y1Input: SCRTDoubleVector): void;
    SetIndices(indices: IntVector): void;
    SetIndicesOut(indices: SCRTDoubleVector): void;
    SetXOut(xOut: SCRTDoubleVector): void;
    SetYOut(yOut: SCRTDoubleVector): void;
    SetY1Out(y1Out: SCRTDoubleVector): void;
    SetY1Offset(y1Offset: number): void;
    count: number;
    isCategoryData: boolean;
    isFifoSweeping: boolean;
    delete(): void;
}
/**
 *WebAssembly / Native Palette base class, used when drawing per-point fill and strokes with our WebAssembly / WebGL2 Rendering Engine, See {@link SCRTPalette} for concrete implementations.
 */
export declare class SCRTPalette {
    GetOptimizedIndex(colorIndex: number): number;
    delete(): void;
}
export declare class ResamplingArgs {
    Reset(): void;
    Resampling: ResamplingMode;
    Data: ResamplingData;
    StartIndex: number;
    EndIndex: number;
    ViewportWidth: number;
    ResamplingPrecision: number;
    MinXInclusive: number;
    MaxXInclusive: number;
    IsFifo: boolean;
    FifoCapacity: number;
    InputBaseIndex: number;
    HasNaN: boolean;
    ZeroLineY: number;
    NewDataPointCount: number;
    OutputSplitIndex: number;
    delete(): void;
}
export declare class SCRTXvaluesProvider {
    SetInput(input: SCRTDoubleVector): void;
    delete(): void;
}
export declare class SCRTDoubleArraysXyResampleOutput {
    ResetWithIndices(indexesOut: SCRTDoubleVector, xOut: SCRTDoubleVector, yOut: SCRTDoubleVector): void;
    Reset(xOut: SCRTDoubleVector, yOut: SCRTDoubleVector): void;
    OutputSplitIndex: number;
    delete(): void;
}
export declare class SCRTDoubleResampler {
    UpdateIndices(indices: IntVector, xInput: SCRTXvaluesProvider, yInput: SCRTDoubleVector, resamplingMode: ResamplingMode, resamplingArgs: ResamplingArgs): number;
    Execute(xInput: SCRTXvaluesProvider, yInput: SCRTDoubleVector, out: SCRTDoubleArraysXyResampleOutput, indicesOut: IntVector, resamplingMode: ResamplingMode, resamplingArgs: ResamplingArgs): void;
    RequiresReduction(resamplingArgs: ResamplingArgs): boolean;
    MergeIndices(indices: IntVector, size1: number, size2: number, mergedIndicesOut: IntVector): number;
    CopyValuesByIndices(params: SCRTDoubleResamplerMergeIndicesParams): void;
    delete(): void;
}
export declare class StringVector {
    dataPtr(offset: number): number;
    push_back(element: string): void;
    pop_back(): void;
    size(): number;
    resize(size: number, initialValue: string): void;
    reserve(size: number): void;
    clear(): void;
    fill(element: string): void;
    insertAt(index: number, element: string): void;
    removeAt(index: number): void;
    removeRange(index: number, count: number): void;
    delete(): void;
    set(index: number, element: string): void;
    get(index: number): string;
}
/**
 *WebAssembly / Native CoordinateCalculator base class: Converts pixel coordinates to data-values and vice versa
 */
export declare class CoordinateCalculator {
    GetCoordinate(dataValue: number): number;
    GetCoordinatesVec(_paDataValues: SCRTDoubleVector, _paOutput: SCRTFloatVector, _iSrcIndex: number, _iDestIndex: number, _iCount: number, _dOffset: number): void;
    GetDataValue(coordinate: number): number;
    CanSupportMatrices(): boolean;
    IsFlipped(): boolean;
    delete(): void;
}
/**
 *WebAssembly / Native Linear Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Double precision version.
 */
export declare class LinearCoordinateCalculatorDouble extends CoordinateCalculator {
    extraOffset: number;
    delete(): void;
}
/**
 *WebAssembly / Native Flipped Linear Coordinate Calculator: Converts pixel coordinates to data-values and vice versa.  Double precision version. Inverse of {@link FlippedLinearCoordinateCalculatorDouble}
 */
export declare class FlippedLinearCoordinateCalculatorDouble extends CoordinateCalculator {
    delete(): void;
}
/**
 *WebAssembly / Native Linear Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Float32 version.
 */
export declare class LinearCoordinateCalculatorSingle extends CoordinateCalculator {
    extraOffset: number;
    delete(): void;
}
/**
 *WebAssembly / Native Flipped Linear Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Float32 version. Inverse of {@link LinearCoordinateCalculatorSingle}
 */
export declare class FlippedLinearCoordinateCalculatorSingle extends CoordinateCalculator {
    delete(): void;
}
/**
 *WebAssembly / Native Catetory Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Uses index not data-value for conversion
 */
export declare class CategoryCoordinateCalculatorDouble extends CoordinateCalculator {
    TransformDataToIndex(dataValue: number, baseXValues: SCRTDoubleVector): number;
    TransformIndexToData(index: number, baseXValues: SCRTDoubleVector): number;
    delete(): void;
}
/**
 *WebAssembly / Native Catetory Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Uses index not data-value for conversion. Inverse of CategoryCoordinateCalculatorDouble
 */
export declare class FlippedCategoryCoordinateCalculatorDouble extends CoordinateCalculator {
    TransformDataToIndex(dataValue: number, baseXValues: SCRTDoubleVector): number;
    TransformIndexToData(index: number, baseXValues: SCRTDoubleVector): number;
    delete(): void;
}
/**
 *WebAssembly / Native Logarithmic Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Double precision version.
 */
export declare class LogarithmicCoordinateCalculator extends CoordinateCalculator {
    delete(): void;
}
/**
 *WebAssembly / Native Flipped Logarithmic Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Double precision version. Inverse of {@link LogarithmicCoordinateCalculator}
 */
export declare class FlippedLogarithmicCoordinateCalculator extends CoordinateCalculator {
    delete(): void;
}
/**
 *WebAssembly / Index Calculator
 */
export declare class IndexCalculator {
    UpdateVec(baseValues: SCRTDoubleVector, SetDataPointWidth: boolean): void;
    ReleaseMemory(): void;
    GetIndex(value: number): number;
    GetValue(index: number): number;
    dataPointWidth: number;
    delete(): void;
}
/**
 *WebAssembly / Index Calculator Params
 */
export declare class IndexCalculatorParams {
    SetIndexCalculator(IndexCalculator: IndexCalculator): void;
    m_dViewportDimension: number;
    m_dVisibleMin: number;
    m_dVisibleMax: number;
    m_dViewportOffset: number;
    m_dCoordOffset: number;
    m_dIndexMin: number;
    m_dIndexMax: number;
    delete(): void;
}
/**
 *WebAssembly / Native Index Coordinate Calculator
 */
export declare class IndexCoordinateCalculator extends CoordinateCalculator {
    delete(): void;
}
/**
 *WebAssembly / Native Flipped Index Coordinate Calculator
 */
export declare class FlippedIndexCoordinateCalculator extends CoordinateCalculator {
    delete(): void;
}
/**
 *WebAssembly / Native SCRTCoordinateTransform base class: Applies a global transformation to pixel coordinates
 */
export declare class SCRTCoordinateTransform {
    TransformPoint(radius: number, angle: number, outVector: TSRVector2): void;
    TransformDataPoint(xCoordCalc: CoordinateCalculator, yCoordCalc: CoordinateCalculator, xValue: number, yValue: number, outVector: TSRVector2): void;
    ReverseTransformPoint(xValue: number, yValue: number, outVector: TSRVector2): void;
    delete(): void;
}
export declare class TSRVector2 {
    x: number;
    y: number;
    delete(): void;
}
/**
 *WebAssembly / Native Polar Coordinate Calculator: Converts pixel coordinates in r,theta to cartesian x,y
 */
export declare class SCRTPolarCoordinateTransform extends SCRTCoordinateTransform {
    XCenter: number;
    YCenter: number;
    StartAngle: number;
    yIsPolar: boolean;
    delete(): void;
}
export declare class SCRTFrameRenderer2D extends SCRTFrameRenderer {
    delete(): void;
}
export declare class SCRTFrameRenderer {
    delete(): void;
}
/**
 *WebAssembly / Draw lines parameters
 */
export declare class SCRTDrawLinesParams {
    SetPointsVec(points: VectorColorVertex): void;
    SetPen(pen: SCRTPen): void;
    SetNanPen(nanPen: SCRTPen): void;
    SetTextureBrush(textureBrush: SCRTTextureBrush): void;
    m_Type: SCRTLineType;
    delete(): void;
}
/**
 *WebAssembly / Native Color vertex type. Includes {@link TSRVector3} position and integer color in RGBA format
 */
export declare class SCRTColorVertex {
    SetPosition(x: number, y: number): void;
    SetColor(color: number): void;
    m_vPosition: TSRVector3;
    m_uiColor: number;
    delete(): void;
}
export declare class VectorColorVertex {
    dataPtr(offset: number): number;
    push_back(element: SCRTColorVertex): void;
    pop_back(): void;
    size(): number;
    resize(size: number, initialValue: SCRTColorVertex): void;
    reserve(size: number): void;
    clear(): void;
    fill(element: SCRTColorVertex): void;
    insertAt(index: number, element: SCRTColorVertex): void;
    removeAt(index: number): void;
    removeRange(index: number, count: number): void;
    delete(): void;
    set(index: number, element: SCRTColorVertex): void;
    get(index: number): SCRTColorVertex;
}
/**
 *WebAssembly / Native Pen, used when drawing strokes with our WebAssembly / WebGL2 Rendering Engine
 */
export declare class SCRTPen {
    m_uiColor: number;
    m_fThickness: number;
    m_bGradient: boolean;
    delete(): void;
}
/**
 *WebAssembly / Native Texture Brush, used when drawing strokes with our WebAssembly / WebGL2 Rendering Engine
 */
export declare class SCRTTextureBrush extends SCRTBrush {
    GetTexture(): TSRTexture;
    SetTexture(texture: TSRTexture): void;
    GetMappingMode(): eSCRTBrushMappingMode;
    SetMappingMode(mappingMode: eSCRTBrushMappingMode): void;
    SetSamplerMode(samplerMode: SCRTTextureBrushSamplerMode): void;
    delete(): void;
}
export declare class SCRTLineType {
}
export declare class SCRTPrimitivesEffect {
}
/**
 *WebAssembly / Draw primitives parameters
 */
export declare class SCRTDrawPrimitivesParams {
    SetVerticesVec(verts: VectorColorTextureVertex): void;
    SetBrush(brush: SCRTBrush): void;
    SetHeightMapTexture(heightmapTexture: TSRTexture): void;
    SetGradientTexture(gradientTexture: TSRTexture): void;
    SetContourParams(contourParams: SCRTContourParams): void;
    m_Effect: SCRTPrimitivesEffect;
    m_vPackedFloatParams: TSRVector4;
    delete(): void;
}
/**
 *WebAssembly / Native Color vertex texture type. Includes {@link TSRVector2} position, integer color in RGBA format and texture coordinate
 */
export declare class SCRTColorTextureVertex {
    SetPosition(x: number, y: number): void;
    SetTexCoord(x: number, y: number): void;
    SetColor(color: number): void;
    m_vPosition: TSRVector2;
    m_vTexCoord: TSRVector2;
    m_uiColor: number;
    delete(): void;
}
export declare class VectorColorTextureVertex {
    dataPtr(offset: number): number;
    push_back(element: SCRTColorTextureVertex): void;
    pop_back(): void;
    size(): number;
    resize(size: number, initialValue: SCRTColorTextureVertex): void;
    reserve(size: number): void;
    clear(): void;
    fill(element: SCRTColorTextureVertex): void;
    insertAt(index: number, element: SCRTColorTextureVertex): void;
    removeAt(index: number): void;
    removeRange(index: number, count: number): void;
    delete(): void;
    set(index: number, element: SCRTColorTextureVertex): void;
    get(index: number): SCRTColorTextureVertex;
}
/**
 *WebAssembly / Native Brush base class, used when drawing strokes with our WebAssembly / WebGL2 Rendering Engine, See {@link SCRTSolidBrush} and {@link SCRTTextureBrush} for concrete implementations.
 */
export declare class SCRTBrush {
    GetColor(): number;
    SetColor(uiColor: number): void;
    GetTransparent(): boolean;
    SetTransparent(transparent: boolean): void;
    GetOpacity(): number;
    SetOpacity(opacity: number): void;
    delete(): void;
}
export declare class SCRTContourParams {
    SetColorVector(x: number, y: number, z: number, w: number): void;
    SetParamsAVector(x: number, y: number, z: number, w: number): void;
    SetParamsBVector(x: number, y: number, z: number, w: number): void;
    m_vColor: TSRVector4;
    m_vParamsA: TSRVector4;
    m_vParamsB: TSRVector4;
    delete(): void;
}
/**
 *WebAssembly / Draw rects parameters
 */
export declare class SCRTDrawRectsParams {
    SetVerticesVec(vertices: VectorRectVertex): void;
    SetBrush(brush: SCRTBrush): void;
    SetPen(pen: SCRTPen): void;
    m_vAnchorParams: TSRVector4;
    m_bIsEllipses: boolean;
    delete(): void;
}
/**
 *WebAssembly / Native Rect vertex type. Includes {@link TSRVector3} position, {@link TSRVector2} size and integer color in RGBA format
 */
export declare class SCRTRectVertex {
    Assign(left: number, top: number, right: number, bottom: number): void;
    m_vPosition: TSRVector2;
    m_vSize: TSRVector2;
    m_uiColor: number;
    delete(): void;
}
export declare class VectorRectVertex {
    dataPtr(offset: number): number;
    push_back(element: SCRTRectVertex): void;
    pop_back(): void;
    size(): number;
    resize(size: number, initialValue: SCRTRectVertex): void;
    reserve(size: number): void;
    clear(): void;
    fill(element: SCRTRectVertex): void;
    insertAt(index: number, element: SCRTRectVertex): void;
    removeAt(index: number): void;
    removeRange(index: number, count: number): void;
    delete(): void;
    set(index: number, element: SCRTRectVertex): void;
    get(index: number): SCRTRectVertex;
}
/**
 *WebAssembly / Draw arcs parameters
 */
export declare class SCRTDrawArcsParams {
    SetVerticesVec(vertices: VectorArcVertex): void;
    SetBrush(brush: SCRTBrush): void;
    SetPen(pen: SCRTPen): void;
    delete(): void;
}
/**
 *WebAssembly / Native Color Arc vertex texture type. Includes {@link TSRVector2} center, {@link TSRVector4} radii,  {@link TSRVector2} start/end angles
 */
export declare class SCRTArcVertex {
    MakeCircularArc(params: SCRTArcParams): void;
    m_vPosition: TSRVector2;
    m_vRadii: TSRVector4;
    m_vAngles: TSRVector2;
    m_vTexCoord: TSRVector2;
    delete(): void;
}
export declare class VectorArcVertex {
    dataPtr(offset: number): number;
    push_back(element: SCRTArcVertex): void;
    pop_back(): void;
    size(): number;
    resize(size: number, initialValue: SCRTArcVertex): void;
    reserve(size: number): void;
    clear(): void;
    fill(element: SCRTArcVertex): void;
    insertAt(index: number, element: SCRTArcVertex): void;
    removeAt(index: number): void;
    removeRange(index: number, count: number): void;
    delete(): void;
    set(index: number, element: SCRTArcVertex): void;
    get(index: number): SCRTArcVertex;
}
export declare class SCRTLineGapMode {
}
export declare class SCRTTriangleDrawMode {
}
/**
 *WebAssembly / Drawing parameters
 */
export declare class SCRTDrawingParams {
    SetNativeContext(NativeContext: SCRTRenderContext): void;
    SetXValues(XValues: SCRTDoubleVector): void;
    SetYValues(YValues: SCRTDoubleVector): void;
    SetZValues(ZValues: SCRTDoubleVector): void;
    SetWValues(WValues: SCRTDoubleVector): void;
    SetXCoordinateCalculator(XCoordinateCalculator: CoordinateCalculator): void;
    SetYCoordinateCalculator(YCoordinateCalculator: CoordinateCalculator): void;
    SetCoordinateTransform(coordTransform: SCRTCoordinateTransform): void;
    count: number;
    startIndex: number;
    verticalChart: boolean;
    forceShaderMethod: boolean;
    delete(): void;
}
/**
 *WebAssembly / Native Drawing or Render Context. Contains functions with drawing commands to access our fast WebGL2 Rendering Engine
 */
export declare class SCRTRenderContext {
    SetClearColor(red: number, green: number, blue: number, alpha: number): void;
    Clear(): void;
    SetViewport(x: number, y: number, width: number, height: number): void;
    OnFrameBegin(): void;
    SetClipRect(x: number, y: number, width: number, height: number): void;
    Rotate(angle: number): void;
    Translate(x: number, y: number): void;
    ResetTransform(): void;
    DrawLines(drawLineParams: SCRTDrawLinesParams): void;
    DrawPrimitives(drawPrimitivesParams: SCRTDrawPrimitivesParams): void;
    DrawRects(drawRectsParams: SCRTDrawRectsParams): void;
    DrawArcs(drawArcssParams: SCRTDrawArcsParams): void;
    AddSeriesEffect(pSeriesEffect: SCRTSeriesEffect): void;
    RemoveSeriesEffect(pSeriesEffect: SCRTSeriesEffect): void;
    ClearSeriesEffects(): void;
    SetBlendMode(blendMode: eSCRTBlendMode): void;
    GetBlendMode(): eSCRTBlendMode;
    CreateTextTexture(fontKey: SCRTFontKey, text: string, frontColor: number, backColor: number): TSRTexture;
    AquireFont(fontKey: SCRTFontKey): SCRTFont;
    delete(): void;
}
/**
 *WebAssembly / Native Line drawing params passed to {@link SCRTLineSeriesDrawingProvider}
 */
export declare class SCRTLineDrawingParams extends SCRTDrawingParams {
    SetLinesPen(linesPen: SCRTPen): void;
    SetPalettedColors(colorValues: IntVector): void;
    SetPalettedColors2(colorValues: IntVector): void;
    Reset(): void;
    paletteStart: number;
    containsNaN: boolean;
    isDigitalLine: boolean;
    drawDigitalVertical: boolean;
    digitalYX: boolean;
    lineGaps: SCRTLineGapMode;
    forceClamp: boolean;
    fourVectorsMode: boolean;
    delete(): void;
}
/**
 *WebAssembly / Native Line drawing provider, which draws batched / fast lines using our WebGL2 Rendering Engine
 */
export declare class SCRTLineSeriesDrawingProvider {
    DrawLinesVec(params: SCRTLineDrawingParams): void;
    delete(): void;
}
/**
 *WebAssembly / Native Smear series parameters, set on {@link SCRTSmearSeriesParams}
 */
export declare class SCRTSmearSeriesParams {
    SetX(xValues: SCRTDoubleVector): void;
    SetY(yValues: SCRTDoubleVector): void;
    SetColorZvalues(zValues: SCRTDoubleVector): void;
    SetColors(colorValues: IntVector): void;
    SetSmearTexture(texture: TSRTexture): void;
    SetHeightColors(heightColorSettings: SCRTHeightColorSettings): void;
    m_iCount: number;
    m_iStartIndex: number;
    m_iColorCount: number;
    m_iColorStartIndex: number;
    m_dYOffset: number;
    smoothColors: boolean;
    m_uiOutOfrangeColor: number;
    delete(): void;
}
/**
 *WebAssembly / Native Discrete Color stops for Height Series, set on {@link SCRTHeightSeriesParams}
 */
export declare class SCRTHeightColorSettings {
    AddColorStop(stop: number, color: number): void;
    Reset(): void;
    m_uiInfra: number;
    m_uiUltra: number;
    m_fMinHeight: number;
    m_fMaxHeight: number;
    m_bIsGradient: boolean;
    m_fMaxTextureSize: number;
    delete(): void;
}
/**
 *WebAssembly / Native Smear series drawing provider, which draws a smeared texture determined by the z Values with offsets determined by the x and y values
 */
export declare class SCRTSmearSeriesDrawingProvider {
    CreateSmearSeriesColorsTexture(colorYvalues: SCRTDoubleVector, yCoordinateCalculator: CoordinateCalculator, smearParams: SCRTSmearSeriesParams): TSRTexture;
    CreateSmearSeriesValuesTexture(xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, smearParams: SCRTSmearSeriesParams): TSRTexture;
    DrawSmearSeries(nativeContext: SCRTRenderContext, smearParams: SCRTSmearSeriesParams): void;
    delete(): void;
}
/**
 *WebAssembly / Native Height series params passed to {@link SCRTHeightSeriesDrawingProvider}
 */
export declare class SCRTHeightSeriesParams extends SCRTDrawingParams {
    SetEdgePen(strokePen: SCRTPen): void;
    SetFillBrush(fillBrush: SCRTBrush): void;
    SetPalettedColors(colorValues: IntVector): void;
    SetHeightColors(heightColorSettings: SCRTHeightColorSettings): void;
    SetHeightsForColoring(heightValues: SCRTDoubleVector): void;
    SetNormalDirection(normalDirection: TSRVector3): void;
    Reset(): void;
    minHeight: number;
    maxHeight: number;
    isInverseHeight: boolean;
    normaliseHeights: boolean;
    paletteStart: number;
    zMultiplier: number;
    interpolate: boolean;
    delete(): void;
}
export declare class TSRVector3 {
    Normalize(): void;
    Dot(param0: TSRVector3): number;
    Cross(param0: TSRVector3, param1: TSRVector3): void;
    Assign(x: number, y: number, z: number): void;
    x: number;
    y: number;
    z: number;
    delete(): void;
}
/**
 *WebAssembly / Native Height series drawing provider
 */
export declare class SCRTHeightSeriesDrawingProvider {
    DrawPointsVec(params: SCRTHeightSeriesParams): void;
    delete(): void;
}
/**
 *WebAssembly / Native Line Segment drawing provider, which draws batched / fast lines using our WebGL2 Rendering Engine
 */
export declare class SCRTLineSegmentDrawingProvider {
    DrawLinesVec(params: SCRTLineDrawingParams): void;
    delete(): void;
}
/**
 *WebAssembly / Native Scatter Point drawing params passed to {@link SCRTScatterSeriesDrawingProvider}
 */
export declare class SCRTHeatmapDrawingParams extends SCRTDrawingParams {
    delete(): void;
}
/**
 *WebAssembly / Native Heatmap drawing provider, which draws non-uniform hetamaps our WebGL2 Rendering Engine
 */
export declare class SCRTHeatmapSeriesDrawingProvider {
    DrawHeatmapNonUniform(params: SCRTHeatmapDrawingParams): void;
    DrawPolarHeatmap(polarTransform: SCRTCoordinateTransform, innerRadius: number, outerRadius: number, startAngle: number, gradientTexture: TSRTexture, heatmapTexture: TSRTexture, packedFloatParams: TSRVector4, contourParams: SCRTContourParams, endAngle: number): void;
    delete(): void;
}
/**
 *WebAssembly / Native Scatter Point drawing params passed to {@link SCRTScatterSeriesDrawingProvider}
 */
export declare class SCRTPointDrawingParams extends SCRTDrawingParams {
    SetSpriteTexture(pointTexture: TSRTexture): void;
    SetStrokeMask(strokeMask: TSRTexture): void;
    SetPalettedColors(palettedColors: IntVector): void;
    Reset(): void;
    paletteStart: number;
    zMultiplier: number;
    usePointSampling: boolean;
    delete(): void;
}
/**
 *WebAssembly / Native Scatter Point drawing provider, which draws batched / fast points using our WebGL2 Rendering Engine
 */
export declare class SCRTScatterSeriesDrawingProvider {
    DrawPointsVec(params: SCRTPointDrawingParams): void;
    delete(): void;
}
/**
 *WebAssembly / Native OHLC/Candlestick drawing params passed to {@link SCRTCandlestickSeriesDrawingProvider}
 */
export declare class SCRTOhlcDrawingParams extends SCRTDrawingParams {
    SetPens(strokeUpPen: SCRTPen, strokeDownPen: SCRTPen): void;
    SetBrushes(fillUpBrush: SCRTBrush, fillDownBrush: SCRTBrush): void;
    SetValues(xValues: SCRTDoubleVector, openValues: SCRTDoubleVector, highValues: SCRTDoubleVector, lowValues: SCRTDoubleVector, closeValues: SCRTDoubleVector): void;
    SetPalettedColors(palettedColors: IntVector): void;
    Reset(): void;
    paletteStart: number;
    candleWidth: number;
    drawAsOhlc: boolean;
    delete(): void;
}
/**
 *WebAssembly / Native Candlestick drawing provider, which draws batched / fast candles using our WebGL2 Rendering Engine
 */
export declare class SCRTCandlestickSeriesDrawingProvider {
    DrawPointsVec(params: SCRTOhlcDrawingParams): void;
    delete(): void;
}
/**
 *WebAssembly / Native Mountain/Area drawing params passed to {@link SCRTMountainSeriesDrawingProvider}
 */
export declare class SCRTMountainDrawingParams extends SCRTBandDrawingParams {
    Reset(): void;
    zeroLineY: number;
    delete(): void;
}
/**
 *WebAssembly / Native Band drawing params passed to {@link SCRTBandSeriesDrawingProvider}
 */
export declare class SCRTBandDrawingParams extends SCRTDrawingParams {
    SetLinesPen(strokePen: SCRTPen): void;
    SetFillBrush(fillBrush: SCRTBrush): void;
    SetLinesPen1(strokePen: SCRTPen): void;
    SetFillBrush1(fillBrush: SCRTBrush): void;
    SetPalette(palette: SCRTPalette): void;
    Reset(): void;
    forceClamp: boolean;
    isDigitalLine: boolean;
    isSmoothColors: boolean;
    lineGaps: SCRTLineGapMode;