@types/gorilla-engine 1.0.0

gorilla-engine/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

gorilla-engine/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/gorilla-engine`
+
+# Summary
+This package contains type definitions for Gorilla Engine (https://gorilla-engine.com).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/gorilla-engine.
+
+### Additional Details
+ * Last updated: Mon, 16 Jan 2023 13:32:40 GMT
+ * Dependencies: none
+ * Global values: `GorillaEngine`
+
+# Credits
+These definitions were written by [Julian Woodward](https://github.com/jhwoodward).

gorilla-engine/components/AmpEnv.d.ts

@@ -0,0 +1,29 @@
+declare namespace GorillaEngine.UI {
+    interface AmpItem {
+        color: string;
+        size: number;
+        cornerRadius: number;
+        value: number;
+        'value&': any;
+        visible: boolean;
+        imagePath: string;
+        text: string;
+        textColor: string;
+    }
+
+    interface AmpEnvProps extends Common, Bounds, Background, Font {
+        attack: Partial<AmpItem>;
+        decay: Partial<AmpItem>;
+        sustain: Partial<AmpItem>;
+        release: Partial<AmpItem>;
+        curve: Partial<{
+            color: string;
+            thickness: number;
+        }>;
+    }
+
+    interface AmpEnv extends AmpEnvProps {}
+    class AmpEnv extends Component {
+        constructor(options: Partial<AmpEnvProps>);
+    }
+}

gorilla-engine/components/BarStepEditor.d.ts

@@ -0,0 +1,28 @@
+declare namespace GorillaEngine.UI {
+    interface BarStepEditorProps extends Common, Bounds, Background, Clickable {
+        value: any;
+        divSize: number;
+        min: number;
+        max: number;
+        paramPath: string;
+        startIndex: number;
+        endIndex: number;
+        step: Partial<{
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+            cornerRadius: number;
+            incrementHeight: number;
+            backgroundColor: string;
+            markDefault: boolean;
+            onColor: string;
+            offColor: string;
+        }>;
+    }
+
+    class BarStepEditor extends Component {
+        constructor(options: Partial<BarStepEditorProps>);
+    }
+    interface BarStepEditor extends BarStepEditorProps {}
+}

gorilla-engine/components/ComboBox.d.ts

@@ -0,0 +1,65 @@
+declare namespace GorillaEngine.UI {
+    interface ComboBoxPadding {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }
+    interface ComboBoxPopupStyles {
+        backgroundColor: string;
+        itemTextColor: string;
+        itemSelectedTextColor: string;
+        itemSelectedBackgroundColor: string;
+        itemHighlightedTextColor: string;
+        itemHighlightedBackgroundColor: string;
+        checkmarkFloat: 'left' | 'right';
+        cornerRadius: number;
+        padding: ComboBoxPadding | number;
+        checkmarkPadding: ComboBoxPadding;
+    }
+
+    interface ComboBoxProps extends Common, Bounds, Background, Clickable, Font {
+        value: number;
+        /**
+         * List of options
+         */
+        items: string[];
+        /**
+         * The character that signifies heirarchy within the items array
+         */
+        levelSeperator: string;
+        stretchText: boolean;
+        scrollWheelEnabled: boolean;
+        styleSubmenu: boolean;
+        backgroundColorClicked: string;
+        backgroundColorHover: string;
+        itemReselectedAction: string;
+        padding: Partial<ComboBoxPadding> | number;
+        images: Partial<{
+            arrowIcon: string;
+            arrowIconPressed: string;
+            popupSubmenuSelectionImage: string;
+            popupSubmenuSelectionHighlightedImage: string;
+            popupCheckmarkImage: string;
+            popupCheckmarkHighlightedImage: string;
+            subPopupSubmenuSelectionImage: string;
+            subPopupSubmenuSelectionHighlightedImage: string;
+            subPopupCheckmarkImage: string;
+            subPopupCheckmarkHighlightedImage: string;
+        }>;
+        popup: Partial<
+            ComboBoxPopupStyles & {
+                separatorColo?: string;
+                separatorHeight: number;
+                separatorPadding: number;
+            }
+        >;
+        subPopup: Partial<ComboBoxPopupStyles>;
+    }
+
+    interface ComboBox extends ComboBoxProps {}
+    class ComboBox extends Component {
+        onChange?: (value: number) => void;
+        constructor(options: Partial<ComboBoxProps>);
+    }
+}

gorilla-engine/components/DragContainer.d.ts

@@ -0,0 +1,19 @@
+declare namespace GorillaEngine.UI {
+    interface DragContainerProps extends Common, Bounds, Clickable {
+        dragGroup: string;
+        dragContent: string;
+        externalDragStartAction: string;
+        externalDragEndAction: string;
+        destinationCanMoveDraggedFiles: boolean;
+        externallyDraggedFiles: any;
+        onDragging: string;
+        onExternalDragStart: string;
+        onExternalDragEnd: string;
+    }
+
+    interface DragContainer extends DragContainerProps {}
+
+    class DragContainer extends Component {
+        constructor(options: Partial<DragContainerProps>);
+    }
+}

gorilla-engine/components/DragTarget.d.ts

@@ -0,0 +1,12 @@
+declare namespace GorillaEngine.UI {
+    interface DragTargetProps extends Common, Bounds, Clickable {
+        dragGroup: string;
+        onDrop: string;
+    }
+
+    class DragTarget extends Component {
+        constructor(options: Partial<DragTargetProps>);
+    }
+
+    interface DragTarget extends DragTargetProps {}
+}

gorilla-engine/components/DropZone.d.ts

@@ -0,0 +1,13 @@
+declare namespace GorillaEngine.UI {
+    interface DropZoneProps extends Common, Bounds, Clickable {
+        acceptedFileTypes: string[] | string;
+        onDraggedFiles: string;
+        onDroppedFile: string;
+    }
+
+    interface DropZone extends DropZoneProps {}
+
+    class DropZone extends Component {
+        constructor(options: Partial<DropZoneProps>);
+    }
+}

gorilla-engine/components/Knob.d.ts

@@ -0,0 +1,13 @@
+declare namespace GorillaEngine.UI {
+    interface KnobProps extends Common, Bounds, Clickable, Background, Skinnable {
+        text: string;
+        min: number;
+        max: number;
+        value: number;
+    }
+
+    interface Knob extends KnobProps {}
+    class Knob extends Component {
+        constructor(options: Partial<KnobProps>);
+    }
+}

gorilla-engine/components/Label.d.ts

@@ -0,0 +1,14 @@
+declare namespace GorillaEngine.UI {
+    interface LabelProps extends Common, Bounds, Background, Font, Clickable {
+        text: string | number;
+        format: string;
+    }
+
+    /**
+     * Use a Label to...
+     */
+    class Label extends Component {
+        constructor(options: Partial<LabelProps>);
+    }
+    interface Label extends LabelProps {}
+}

gorilla-engine/components/LevelMeter.d.ts

@@ -0,0 +1,28 @@
+declare namespace GorillaEngine.UI {
+    interface LevelMeterProps extends Common, Bounds, Background, Skinnable {
+        peakHold: boolean;
+        logScale: boolean;
+        fillArea: boolean;
+        inverted: boolean;
+        stereo: boolean;
+        positionIndicator: boolean;
+        rampUpFactor: number;
+        rampDownFactor: number;
+        maxRampDownSpeed: number;
+        min: number;
+        max: number;
+        levelColor: string;
+        peakColor: string;
+        indicatorThickness: number;
+        visibleSectionStart: number;
+        visibleSectionEnd: number;
+        direction: string;
+        value: any;
+    }
+
+    interface LevelMeter extends LevelMeterProps {}
+
+    class LevelMeter extends Component {
+        constructor(options: Partial<LevelMeterProps>);
+    }
+}

gorilla-engine/components/ListBox.d.ts

@@ -0,0 +1,17 @@
+declare namespace GorillaEngine.UI {
+    interface ListBoxProps extends Common, Bounds, Font, Clickable, Background, Scrollable {
+        items?: string[];
+        horizontalMargin?: number;
+        cellColor?: string;
+        cellColorSelected?: string;
+        textColorSelected?: string;
+        rowDoubleClickedAction?: string;
+        returnKeyAction?: string;
+        rowClickedAction?: string;
+    }
+
+    interface ListBox extends ListBoxProps {}
+    class ListBox extends Component {
+        constructor(options: Partial<ListBoxProps>);
+    }
+}

gorilla-engine/components/LottieAnimation.d.ts

@@ -0,0 +1,35 @@
+declare namespace GorillaEngine.UI {
+    interface LottieAnimationProps extends Common, Bounds {
+        filePath: string;
+        autoplay: boolean;
+        loop: boolean;
+        readonly totalFrames?: number;
+        readonly duration?: number;
+        readonly currentFrame?: number;
+        play(): void;
+        stop(): void;
+        pause(): void;
+        setFrame(frame: number): void;
+        setFrameFromLinearTransform(value: number, min: number, max: number): void;
+        setProperties(
+            selector: string,
+            settings: {
+                fillColor?: [number, number, number]; // Fill bright red
+                fillOpacity?: number; // Change fills to 50% opacity
+                strokeColor?: [number, number, number]; // Color strokes bright green
+                strokeOpacity?: number; // Change strokes to 50% opacity
+                strokeWidth?: number; // Change stroke width to 3.5px
+                transformAnchor?: [number, number]; // Move the anchor to x = 100, y = 100
+                transformPosition?: [number, number]; // Move to x = 200, y = 200
+                transformScale?: [number, number]; // Scale to 50% size in x and y axis
+                transformRotation?: number; // Rotate by 180°
+                transformOpacity?: number; // Change opacity to 50%
+            },
+        ): void;
+    }
+
+    class LottieAnimation extends Component {
+        constructor(options: Partial<LottieAnimationProps>);
+    }
+    interface LottieAnimation extends LottieAnimationProps {}
+}

gorilla-engine/components/MidiKeyboard.d.ts

@@ -0,0 +1,37 @@
+declare namespace GorillaEngine.UI {
+    interface MidiKeyboardKeys {
+        blackColor: string;
+        blackHoverColor: string;
+        blackPressedColor: string;
+        blackOutlineColor: string;
+        blackOutlineHoverColor: string;
+        blackOutlinePressedColor: string;
+        whiteColor: string;
+        whiteHoverColor: string;
+        whitePressedColor: string;
+        whiteOutlineColor: string;
+        whiteOutlineHoverColor: string;
+        whiteOutlinePressedColor: string;
+        whiteHeight: number;
+        blackHeight: number;
+        whiteWidth: number;
+        blackWidth: number;
+        width: number;
+        spacing: number;
+        outlineWidth: number;
+        cornerRadius: number;
+    }
+
+    interface MidiKeyboardProps extends Common, Bounds, Background {
+        lowKey: number;
+        highKey: number;
+        disableNKSColors: boolean;
+        keys: Partial<MidiKeyboardKeys>;
+    }
+
+    interface MidiKeyboard extends MidiKeyboardProps {}
+
+    class MidiKeyboard extends Component {
+        constructor(props: Partial<MidiKeyboardProps>);
+    }
+}

gorilla-engine/components/Pad.d.ts

@@ -0,0 +1,17 @@
+declare namespace GorillaEngine.UI {
+    interface PadProps extends Common, Bounds, Background, KeyboardFocus {
+        midiNote: number;
+        velocity: number;
+        padState: boolean;
+        images: Partial<{
+            normal: string;
+            hover: string;
+            down: string;
+        }>;
+    }
+
+    interface Pad extends PadProps {}
+    class Pad extends Component {
+        constructor(options: Partial<PadProps>);
+    }
+}

gorilla-engine/components/ScrollView.d.ts

@@ -0,0 +1,12 @@
+declare namespace GorillaEngine.UI {
+    interface ScrollViewProps extends Common, Bounds, Scrollable {
+        scrollbarThickness: number;
+        hideVerticalScrollbar: boolean;
+        hideHorizontalScrollbar: boolean;
+    }
+
+    class ScrollView extends Component {
+        constructor(options: Partial<ScrollViewProps>);
+    }
+    interface ScrollView extends ScrollViewProps {}
+}

gorilla-engine/components/SliceEditor.d.ts

@@ -0,0 +1,70 @@
+declare namespace GorillaEngine.UI {
+    interface SliceStyle {
+        y: number;
+        width: number;
+        height: number;
+        color: string;
+        image: string;
+    }
+
+    interface Modulation {
+        color: string;
+        tooltip: string;
+        centerLine: any;
+        values: any;
+        centerValue: number;
+    }
+    interface GridMeasure {
+        fractionOfBar: number;
+        showLabels: boolean;
+        tickHeight: number;
+        font: string;
+    }
+
+    interface SliceEditorProps extends Common, Bounds, Background, Clickable {
+        slices: any;
+        audioLengthInSamples: number;
+        audioLengthInBeats: number;
+        canChangeSlices: boolean;
+        canAddSlices: boolean;
+        canRemoveSlices: boolean;
+        snapSlicesToGrid: boolean;
+        zoom: { start: number; end: number };
+        addModulation(modulation: Partial<Modulation>): void;
+        grid: Partial<{
+            position: string;
+            height: number;
+            minTickSpacing: number;
+            enabled: boolean;
+            backgroundColor: string;
+            backgroundImage: string;
+            measures: GridMeasure[];
+            addMeasure(measure: GridMeasure): void;
+        }>;
+        sliceStyles: Partial<{
+            normal: Partial<SliceStyle>;
+            hover: Partial<SliceStyle>;
+            selected: Partial<SliceStyle>;
+        }>;
+        selectionAreaStyle: Partial<{
+            backgroundColor: string;
+            border: Partial<{
+                width: number;
+                radius: number;
+                color: string;
+            }>;
+        }>;
+        addMarker(marker: any): void;
+        addSlice(slice: any): void;
+        clearSlices(): void;
+        setZoom: (start: number, end: number) => void;
+        mappedSampleChanged(): void;
+        modulations: Modulation[];
+    }
+
+    interface SliceEditor extends SliceEditorProps {}
+
+    class SliceEditor extends Component {
+        constructor(options: Partial<SliceEditorProps>);
+    }
+}

gorilla-engine/components/Slider.d.ts

@@ -0,0 +1,24 @@
+declare namespace GorillaEngine.UI {
+    interface SliderProps extends Common, Bounds, Clickable, Background {
+        text: string;
+        min: number;
+        max: number;
+        value: number;
+        direction: 'horizontal' | 'vertical';
+        animation: LottieAnimation;
+        filmstrip: {
+            path: string;
+            count: number;
+            direction: string;
+        };
+    }
+
+    /**
+     * Use a slider to
+     * - enable users to control numeric values by dragging up/down or left/right
+     */
+    class Slider extends Component {
+        constructor(options: Partial<SliderProps>);
+    }
+    interface Slider extends SliderProps {}
+}

gorilla-engine/components/StepEditor.d.ts

@@ -0,0 +1,29 @@
+declare namespace GorillaEngine.UI {
+    interface StepEditorProps extends Common, Background, Bounds, Clickable {
+        value: any;
+        divSize: number;
+        min: number;
+        max: number;
+        paramPath: string;
+        startIndex: number;
+        endIndex: number;
+        step: Partial<{
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+            cornerRadius: number;
+            border: number;
+            markDefault: boolean;
+            incrementHeight: number;
+            backgroundColor: string;
+            onColor: string;
+            offColor: string;
+        }>;
+    }
+
+    interface StepEditor extends StepEditorProps {}
+    class StepEditor extends Component {
+        constructor(options: Partial<StepEditorProps>);
+    }
+}

gorilla-engine/components/TextBox.d.ts

@@ -0,0 +1,24 @@
+declare namespace GorillaEngine.UI {
+    interface TextBoxProps extends Font, Clickable, Bounds, Background {
+        text: string;
+        palceholder: string;
+        unit: string;
+        placeHolderColor: string;
+        highlightTextColor: string;
+        highlightColor: string;
+        cartColor: string;
+        maxLength: number;
+        passwordCharacter: string;
+        multiLine: boolean;
+        readOnly: boolean;
+        acceptedDataType: 'integer' | 'int' | 'float' | 'string';
+        minValue: number;
+        maxValue: number;
+    }
+
+    interface TextBox extends TextBoxProps {}
+
+    class TextBox extends Component {
+        constructor(props: Partial<TextBoxProps>);
+    }
+}

gorilla-engine/components/Toggle.d.ts

@@ -0,0 +1,30 @@
+declare namespace GorillaEngine.UI {
+    interface ToggleProps extends Common, Bounds {
+        text: string;
+        onColor: string;
+        offColor: string;
+        onColorHover: string;
+        offColorHover: string;
+        textColorOn: string;
+        textColorOff: string;
+        textColorOnHover: string;
+        textColorOffHover: string;
+        onImage: string;
+        onImagePressed: string;
+        onImageHovered: string;
+        offImage: string;
+        offImagePressed: string;
+        offImageHovered: string;
+        disabledImage: string;
+        radioIndex: number;
+        radioValue: number;
+        drawTick: boolean;
+        fitToText: boolean;
+        value: boolean;
+        animation: LottieAnimation;
+    }
+    interface Toggle extends ToggleProps {}
+    class Toggle extends Component {
+        constructor(options: Partial<ToggleProps>);
+    }
+}

gorilla-engine/components/Trigger.d.ts

@@ -0,0 +1,16 @@
+declare namespace GorillaEngine.UI {
+    interface TriggerProps extends Common, Bounds, Font, Clickable, Background, KeyboardFocus {
+        text: string;
+        images: {
+            normal?: string;
+            hover?: string;
+            down?: string;
+        };
+        animation: LottieAnimation;
+    }
+
+    interface Trigger extends TriggerProps {}
+    class Trigger extends Component {
+        constructor(options: Partial<TriggerProps>);
+    }
+}

gorilla-engine/components/Waveform.d.ts

@@ -0,0 +1,48 @@
+declare namespace GorillaEngine.UI {
+    interface WaveformDragZone {
+        x: number;
+        y: number;
+        x2: number;
+        y2: number;
+        leftHandleImage: number;
+        rightHandleImage: number;
+        backgroundColor: string;
+        overlayColor: string;
+        leftHandleWidth: number;
+        rightHandleWidth: number;
+        rightHandleHeight: number;
+        canResize: boolean;
+        canPan: boolean;
+        enabled: boolean;
+        markers: Partial<{
+            leftHandleImage: number;
+            rightHandleImage: number;
+            backgroundColor: string;
+            leftHandleWidth: number;
+            leftHandleHeight: number;
+            rightHandleWidth: number;
+            rightHandleHeight: number;
+            canResize: boolean;
+        }>;
+    }
+
+    interface WaveformProps extends Common, Bounds, Background, Font, Clickable {
+        waveformColor: string;
+        gradientCenterColor: string;
+        gradientEndColor: string;
+        horizontalAxisColor: string;
+        waveformUnavailableText: string;
+        waveWidth: number;
+        waveHorizontalSapcing: number;
+        verticalPadding: number;
+        fitHeight: boolean;
+        paintCenterLine: boolean;
+        value: number;
+        dragzone: Partial<WaveformDragZone>;
+    }
+
+    interface Waveform extends WaveformProps {}
+    class Waveform extends Component {
+        constructor(options: Partial<WaveformProps>);
+    }
+}

gorilla-engine/index.d.ts

@@ -0,0 +1,101 @@
+// Type definitions for Gorilla Engine 1.0
+// Project: https://gorilla-engine.com
+// Definitions by: Julian Woodward <https://github.com/jhwoodward>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path = "interfaces/Background.d.ts" />
+/// <reference path = "interfaces/Bounds.d.ts" />
+/// <reference path = "interfaces/Clickable.d.ts" />
+/// <reference path = "interfaces/Common.d.ts" />
+/// <reference path = "interfaces/Component.d.ts" />
+/// <reference path = "interfaces/Font.d.ts" />
+/// <reference path = "interfaces/KeyboardFocus.d.ts" />
+/// <reference path = "interfaces/Scrollable.d.ts" />
+/// <reference path = "interfaces/Skinnable.d.ts" />
+
+/// <reference path = "components/AmpEnv.d.ts" />
+/// <reference path = "components/BarStepEditor.d.ts" />
+/// <reference path = "components/ComboBox.d.ts" />
+/// <reference path = "components/DragContainer.d.ts" />
+/// <reference path = "components/DragTarget.d.ts" />
+/// <reference path = "components/DropZone.d.ts" />
+/// <reference path = "components/Knob.d.ts" />
+/// <reference path = "components/Label.d.ts" />
+/// <reference path = "components/LevelMeter.d.ts" />
+/// <reference path = "components/ListBox.d.ts" />
+/// <reference path = "components/LottieAnimation.d.ts" />
+/// <reference path = "components/MidiKeyboard.d.ts" />
+/// <reference path = "components/Pad.d.ts" />
+/// <reference path = "components/ScrollView.d.ts" />
+/// <reference path = "components/SliceEditor.d.ts" />
+/// <reference path = "components/Slider.d.ts" />
+/// <reference path = "components/StepEditor.d.ts" />
+/// <reference path = "components/TextBox.d.ts" />
+/// <reference path = "components/Toggle.d.ts" />
+/// <reference path = "components/Trigger.d.ts" />
+/// <reference path = "components/Waveform.d.ts" />
+
+declare namespace GorillaEngine {
+    /**
+     * Instrument parameter session persistence
+     */
+    interface InstrumentPropertyPersistence {
+        private: boolean;
+        showInHost: boolean;
+        saveInSession: boolean;
+        saveInPreset: boolean;
+    }
+    /**
+     * Instrument property
+     */
+    interface InstrumentProperty {
+        normValue: number;
+        value: number;
+        normValueAsync: number;
+        valueAsync: number;
+        defaultValue: number;
+        minValue: number;
+        maxValue: number;
+        resolution: number;
+        numSteps: number;
+        key: string;
+        name: string;
+        category: string;
+        label: string;
+        text: string;
+        unit: string;
+        steps: string[];
+        persistence: InstrumentPropertyPersistence;
+    }
+
+    /**
+     * Instrument
+     */
+    interface Instrument {
+        on(propName: string, handler: (normValue: number) => void): void;
+    }
+
+    /**
+     * Blob
+     */
+    interface Blob {
+        loadInstrument(name: string): Instrument;
+        getInstrumentNames(): string[];
+    }
+
+    function registerUncaughtUIExceptionCallback(handler: (err: Error) => void): void;
+    function getResourcePath(): string;
+    function getPluginName(): string;
+    function getManufacturerName(): string;
+    function loadBlob(blobPath: string): Blob;
+    function disposeInstrument(instrument: Instrument): void;
+    function setActiveInstrument(instrument: Instrument): void;
+    function setSessionSaveCallback(callback: any, instance: any): void;
+    function setSessionLoadCallback(callback: any, instance: any): void;
+    function getBuildInformation(): any;
+
+    namespace UI {
+        function loadUIfromYAML(ymlPath: string): void;
+        function getControlById(id: string): Component;
+    }
+}

gorilla-engine/interfaces/Background.d.ts

@@ -0,0 +1,12 @@
+declare namespace GorillaEngine.UI {
+    interface Background {
+        backgroundImage: string;
+        backgroundColor: string;
+        cornerRadius: number;
+        border: {
+            width: number;
+            color: string;
+            focusColor: string;
+        };
+    }
+}

gorilla-engine/interfaces/Bounds.d.ts

@@ -0,0 +1,11 @@
+declare namespace GorillaEngine.UI {
+    interface Bounds {
+        /**
+         * The x position of the component
+         */
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }
+}

gorilla-engine/interfaces/Clickable.d.ts

@@ -0,0 +1,31 @@
+declare namespace GorillaEngine.UI {
+    interface Clickable {
+        interceptsMouseClicks: boolean;
+        allowClicksOnChildren: boolean;
+        modifiedClickAction: string;
+        doubleClickAction: string;
+        mouseEnterAction: string;
+        mouseExitAction: string;
+        clickMask: string;
+        mouseCursorType:
+            | 'none'
+            | 'normal'
+            | 'wait'
+            | 'IBeam'
+            | 'cross hair'
+            | 'copying'
+            | 'pointing hand'
+            | 'dragging hand'
+            | 'left right resize'
+            | 'up down resize'
+            | 'up down left right resize'
+            | 'top edge resize'
+            | 'bottom edge resize'
+            | 'left edge resize'
+            | 'right edge resize'
+            | 'top left corner resize'
+            | 'top right corner resize'
+            | 'bottom left corner resize'
+            | 'bottom right corner resize';
+    }
+}

gorilla-engine/interfaces/Common.d.ts

@@ -0,0 +1,11 @@
+declare namespace GorillaEngine.UI {
+    interface Common {
+        id: string;
+        visible: boolean;
+        enabled: boolean;
+        wantsKeyboardFocus: boolean;
+        clickGrabsKeyboardFocus: boolean;
+        alpha: number;
+        alwaysOnTop: boolean;
+    }
+}

gorilla-engine/interfaces/Component.d.ts

@@ -0,0 +1,11 @@
+declare namespace GorillaEngine.UI {
+    abstract class Component {
+        id: string;
+        children: Component[];
+        parent: Component;
+        on(event: string, handler: any): void;
+        appendChild(child: Component): void;
+        removeChild(child: Component): void;
+        insertBefore(child: Component, beforeChild: Component): void;
+    }
+}

gorilla-engine/interfaces/Font.d.ts

@@ -0,0 +1,20 @@
+declare namespace GorillaEngine.UI {
+    interface Font {
+        font: string;
+        fontSize: number;
+        fontKerning: number;
+        textColor: string;
+        textAlign:
+            | 'centered left'
+            | 'centered right'
+            | 'left'
+            | 'right'
+            | 'center'
+            | 'top left'
+            | 'top right'
+            | 'top center'
+            | 'bottom left'
+            | 'bottom right'
+            | 'bottom center';
+    }
+}

gorilla-engine/interfaces/KeyboardFocus.d.ts

@@ -0,0 +1,7 @@
+declare namespace GorillaEngine.UI {
+    interface KeyboardFocus {
+        keyboardFocus: {
+            color?: string;
+        };
+    }
+}

gorilla-engine/interfaces/Scrollable.d.ts

@@ -0,0 +1,9 @@
+declare namespace GorillaEngine.UI {
+    interface Scrollable {
+        scrollbar?: {
+            background?: string;
+            track?: string;
+            thumb?: string;
+        };
+    }
+}

gorilla-engine/interfaces/Skinnable.d.ts

@@ -0,0 +1,10 @@
+declare namespace GorillaEngine.UI {
+    interface Skinnable {
+        filmstrip: {
+            path: string;
+            count: number;
+            direction: string;
+        };
+        animation: LottieAnimation;
+    }
+}

gorilla-engine/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@types/gorilla-engine",
+    "version": "1.0.0",
+    "description": "TypeScript definitions for Gorilla Engine",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/gorilla-engine",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Julian Woodward",
+            "url": "https://github.com/jhwoodward",
+            "githubUsername": "jhwoodward"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/gorilla-engine"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "e54ee785bb3ed2374e79e767dd76f29c6effd5a33a81e05f15ff8b4bef5ce68f",
+    "typeScriptVersion": "4.2"
+}