@mapbox/mapbox-gl-style-spec 14.4.0 → 14.5.0

package/validate/{validate_function.js → validate_function.ts}

@@ -1,27 +1,25 @@
-// @flow
-
-import ValidationError from '../error/validation_error.js';
-import getType from '../util/get_type.js';
-import validate from './validate.js';
-import validateObject from './validate_object.js';
-import validateArray from './validate_array.js';
-import validateNumber from './validate_number.js';
-import {isExpression} from '../expression/index.js';
-import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint.js';
+import ValidationError from '../error/validation_error';
+import getType from '../util/get_type';
+import validate from './validate';
+import validateObject from './validate_object';
+import validateArray from './validate_array';
+import validateNumber from './validate_number';
+import {isExpression} from '../expression/index';
+import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint';
 import {
     supportsPropertyExpression,
     supportsZoomExpression,
     supportsInterpolation
-} from '../util/properties.js';
+} from '../util/properties';
 
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 export default function validateFunction(options: ValidationOptions): any {
     const functionValueSpec = options.valueSpec;
     const functionType = unbundle(options.value.type);
     let stopKeyType;
-    let stopDomainValues: {[string | number]: boolean} = {};
-    let previousStopDomainValue: ?mixed;
+    let stopDomainValues: Partial<Record<string | number, boolean>> = {};
+    let previousStopDomainValue: unknown | null | undefined;
     let previousStopDomainZoom;
 
     const isZoomFunction = functionType !== 'categorical' && options.value.property === undefined;
@@ -195,10 +193,10 @@ export default function validateFunction(options: ValidationOptions): any {
             previousStopDomainValue = value;
         }
 
-        if (functionType === 'categorical' && (value: any) in stopDomainValues) {
+        if (functionType === 'categorical' && (value as any) in stopDomainValues) {
             return [new ValidationError(options.key, reportValue, 'stop domain values must be unique')];
         } else {
-            stopDomainValues[(value: any)] = true;
+            stopDomainValues[(value as any)] = true;
         }
 
         return [];

package/validate/{validate_glyphs_url.js → validate_glyphs_url.ts}

@@ -1,9 +1,7 @@
-// @flow
+import ValidationError from '../error/validation_error';
+import validateString from './validate_string';
 
-import ValidationError from '../error/validation_error.js';
-import validateString from './validate_string.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 export default function(options: ValidationOptions): Array<ValidationError> {
     const value = options.value;

package/validate/validate_image.ts

@@ -0,0 +1,13 @@
+import validateExpression from './validate_expression';
+import validateString from './validate_string';
+
+import type {ValidationOptions} from './validate';
+import type ValidationError from '../error/validation_error';
+
+export default function validateImage(options: ValidationOptions): Array<ValidationError> {
+    if (validateString(options).length === 0) {
+        return [];
+    }
+
+    return validateExpression(options);
+}

package/validate/{validate_import.js → validate_import.ts}

@@ -1,12 +1,10 @@
-// @flow
+import extend from '../util/extend';
+import validateStyle from './validate_style';
+import validateObject from './validate_object';
+import ValidationError from '../error/validation_error';
+import {unbundle} from '../util/unbundle_jsonlint';
 
-import extend from '../util/extend.js';
-import validateStyle from './validate_style.js';
-import validateObject from './validate_object.js';
-import ValidationError from '../error/validation_error.js';
-import {unbundle} from '../util/unbundle_jsonlint.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 export default function validateImport(options: ValidationOptions): ValidationError[] {
     const {value, styleSpec} = options;

package/validate/{validate_layer.js → validate_layer.ts}

@@ -1,21 +1,19 @@
-// @flow
+import ValidationError from '../error/validation_error';
+import {unbundle} from '../util/unbundle_jsonlint';
+import validateObject from './validate_object';
+import validateFilter from './validate_filter';
+import validatePaintProperty from './validate_paint_property';
+import validateLayoutProperty from './validate_layout_property';
+import validateSpec from './validate';
+import extend from '../util/extend';
 
-import ValidationError from '../error/validation_error.js';
-import {unbundle} from '../util/unbundle_jsonlint.js';
-import validateObject from './validate_object.js';
-import validateFilter from './validate_filter.js';
-import validatePaintProperty from './validate_paint_property.js';
-import validateLayoutProperty from './validate_layout_property.js';
-import validateSpec from './validate.js';
-import extend from '../util/extend.js';
-
-import type {ValidationOptions} from './validate.js';
-import type {LayerSpecification} from '../types.js';
+import type {ValidationOptions} from './validate';
+import type {LayerSpecification} from '../types';
 
 type Options = ValidationOptions & {
     value: LayerSpecification;
     arrayIndex: number;
-}
+};
 
 export default function validateLayer(options: Options): Array<ValidationError> {
     let errors = [];
@@ -36,7 +34,7 @@ export default function validateLayer(options: Options): Array<ValidationError>
         for (let i = 0; i < options.arrayIndex; i++) {
             const otherLayer = style.layers[i];
             if (unbundle(otherLayer.id) === layerId) {
-                // $FlowFixMe[prop-missing] - id.__line__ is added dynamically during the readStyle step
+                // @ts-expect-error - TS2339 - Property '__line__' does not exist on type 'string'.
                 errors.push(new ValidationError(key, layer.id, `duplicate layer id "${layer.id}", previously used at line ${otherLayer.id.__line__}`));
             }
         }
@@ -58,7 +56,6 @@ export default function validateLayer(options: Options): Array<ValidationError>
         if (!parent) {
             if (typeof ref === 'string')
                 errors.push(new ValidationError(key, layer.ref, `ref layer "${ref}" not found`));
-        // $FlowFixMe[prop-missing] - ref is not defined on the LayerSpecification subtypes
         } else if (parent.ref) {
             errors.push(new ValidationError(key, layer.ref, 'ref cannot reference another ref layer'));
         } else {
@@ -80,9 +77,11 @@ export default function validateLayer(options: Options): Array<ValidationError>
                 errors.push(new ValidationError(key, layer, `layer "${layer.id}" must specify a "source-layer"`));
             } else if (sourceType === 'raster-dem' && type !== 'hillshade') {
                 errors.push(new ValidationError(key, layer.source, 'raster-dem source can only be used with layer type \'hillshade\'.'));
+                // @ts-expect-error - TS2345 - Argument of type 'unknown' is not assignable to parameter of type 'string'.
             } else if (sourceType === 'raster-array' && !['raster', 'raster-particle'].includes(type)) {
                 errors.push(new ValidationError(key, layer.source, `raster-array source can only be used with layer type \'raster\'.`));
             } else if (type === 'line' && layer.paint && (layer.paint['line-gradient'] || layer.paint['line-trim-offset']) &&
+            // @ts-expect-error - TS2339 - Property 'lineMetrics' does not exist on type 'SourceSpecification'.
                        (sourceType !== 'geojson' || !source.lineMetrics)) {
                 errors.push(new ValidationError(key, layer, `layer "${layer.id}" specifies a line-gradient, which requires a GeoJSON source with \`lineMetrics\` enabled.`));
             } else if (type === 'raster-particle' && sourceType !== 'raster-array') {
@@ -110,6 +109,7 @@ export default function validateLayer(options: Options): Array<ValidationError>
                     valueSpec: styleSpec.layer.type,
                     style: options.style,
                     styleSpec: options.styleSpec,
+                    // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'object' does not exist in type 'ValidationOptions'.
                     object: layer,
                     objectKey: 'type'
                 });
@@ -119,6 +119,7 @@ export default function validateLayer(options: Options): Array<ValidationError>
             },
             layout(options) {
                 return validateObject({
+                    // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'layer' does not exist in type 'Options'.
                     layer,
                     key: options.key,
                     value: options.value,
@@ -134,6 +135,7 @@ export default function validateLayer(options: Options): Array<ValidationError>
             },
             paint(options) {
                 return validateObject({
+                    // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'layer' does not exist in type 'Options'.
                     layer,
                     key: options.key,
                     value: options.value,

package/validate/{validate_layout_property.js → validate_layout_property.ts}

@@ -1,9 +1,7 @@
-// @flow
+import validateProperty from './validate_property';
 
-import validateProperty from './validate_property.js';
-
-import type ValidationError from '../error/validation_error.js';
-import type {PropertyValidationOptions} from './validate_property.js';
+import type ValidationError from '../error/validation_error';
+import type {PropertyValidationOptions} from './validate_property';
 
 export default function validateLayoutProperty(options: PropertyValidationOptions): Array<ValidationError> {
     return validateProperty(options, 'layout');

package/validate/{validate_light.js → validate_light.ts}

@@ -1,10 +1,8 @@
-// @flow
+import ValidationError from '../error/validation_error';
+import getType from '../util/get_type';
+import validate from './validate';
 
-import ValidationError from '../error/validation_error.js';
-import getType from '../util/get_type.js';
-import validate from './validate.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 export default function validateLight(options: ValidationOptions): Array<ValidationError> {
     const light = options.value;

package/validate/{validate_lights.js → validate_lights.ts}

@@ -1,15 +1,13 @@
-// @flow
+import {default as ValidationError, ValidationWarning} from '../error/validation_error';
+import getType from '../util/get_type';
+import validate from './validate';
+import {unbundle} from '../util/unbundle_jsonlint';
 
-import {default as ValidationError, ValidationWarning} from '../error/validation_error.js';
-import getType from '../util/get_type.js';
-import validate from './validate.js';
-import {unbundle} from '../util/unbundle_jsonlint.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 type Options = ValidationOptions & {
     arrayIndex: number;
-}
+};
 
 export default function validateLights(options: Options): Array<ValidationError> {
     const light = options.value;
@@ -43,7 +41,7 @@ export default function validateLights(options: Options): Array<ValidationError>
             const lightType = unbundle(light.type);
             const otherLight = lights[i];
             if (unbundle(otherLight.type) === lightType) {
-                // $FlowFixMe[prop-missing] - id.__line__ is added dynamically during the readStyle step
+                // @ts-expect-error - TS2339 - Property '__line__' does not exist on type 'string'.
                 errors.push(new ValidationError(key, light.id, `duplicate light type "${light.type}", previously defined at line ${otherLight.id.__line__}`));
             }
         }

package/validate/{validate_model.js → validate_model.ts}

@@ -1,9 +1,7 @@
-// @flow
+import ValidationError from '../error/validation_error';
+import getType from '../util/get_type';
 
-import ValidationError from '../error/validation_error.js';
-import getType from '../util/get_type.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 // Allow any URL, use dummy base, if it's a relative URL
 export function isValidUrl(str: string, allowRelativeUrls: boolean): boolean {
@@ -11,7 +9,7 @@ export function isValidUrl(str: string, allowRelativeUrls: boolean): boolean {
     try {
         new URL(str, isRelative && allowRelativeUrls ? 'http://example.com' : undefined);
         return true;
-    } catch (_) {
+    } catch (_: any) {
         return false;
     }
 }

package/validate/{validate_number.js → validate_number.ts}

@@ -1,13 +1,11 @@
-// @flow
+import getType from '../util/get_type';
+import ValidationError from '../error/validation_error';
 
-import getType from '../util/get_type.js';
-import ValidationError from '../error/validation_error.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 type Options = ValidationOptions & {
     arrayIndex: number;
-}
+};
 
 export default function validateNumber(options: Options): Array<ValidationError> {
     const key = options.key;

package/validate/{validate_object.js → validate_object.ts}

@@ -1,13 +1,11 @@
-// @flow
+import {default as ValidationError, ValidationWarning} from '../error/validation_error';
+import getType from '../util/get_type';
+import validateSpec from './validate';
 
-import {default as ValidationError, ValidationWarning} from '../error/validation_error.js';
-import getType from '../util/get_type.js';
-import validateSpec from './validate.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 type Options = ValidationOptions & {
-    objectElementValidators?: Function;
+    objectElementValidators?: any;
 };
 
 export default function validateObject(options: Options): Array<ValidationError> {
@@ -52,7 +50,6 @@ export default function validateObject(options: Options): Array<ValidationError>
             styleSpec,
             object,
             objectKey
-        // $FlowFixMe[extra-arg]
         }, object));
     }
 

package/validate/{validate_paint_property.js → validate_paint_property.ts}

@@ -1,9 +1,7 @@
-// @flow
+import validateProperty from './validate_property';
 
-import validateProperty from './validate_property.js';
-
-import type ValidationError from '../error/validation_error.js';
-import type {PropertyValidationOptions} from './validate_property.js';
+import type ValidationError from '../error/validation_error';
+import type {PropertyValidationOptions} from './validate_property';
 
 export default function validatePaintProperty(options: PropertyValidationOptions): Array<ValidationError> {
     return validateProperty(options, 'paint');

package/validate/{validate_projection.js → validate_projection.ts}

@@ -1,10 +1,8 @@
-// @flow
+import ValidationError from '../error/validation_error';
+import getType from '../util/get_type';
+import validate from './validate';
 
-import ValidationError from '../error/validation_error.js';
-import getType from '../util/get_type.js';
-import validate from './validate.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 export default function validateProjection(options: ValidationOptions): Array<ValidationError> {
     const projection = options.value;

package/validate/{validate_property.js → validate_property.ts}

@@ -1,21 +1,19 @@
-// @flow
+import validate from './validate';
+import {default as ValidationError, ValidationWarning} from '../error/validation_error';
+import getType from '../util/get_type';
+import {isFunction} from '../function/index';
+import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint';
+import {supportsLightExpression, supportsPropertyExpression, supportsZoomExpression} from '../util/properties';
+import {isGlobalPropertyConstant, isFeatureConstant, isStateConstant} from '../expression/is_constant';
 
-import validate from './validate.js';
-import {default as ValidationError, ValidationWarning} from '../error/validation_error.js';
-import getType from '../util/get_type.js';
-import {isFunction} from '../function/index.js';
-import {unbundle, deepUnbundle} from '../util/unbundle_jsonlint.js';
-import {supportsLightExpression, supportsPropertyExpression, supportsZoomExpression} from '../util/properties.js';
-import {isGlobalPropertyConstant, isFeatureConstant, isStateConstant} from '../expression/is_constant.js';
-
-import type {ValidationOptions} from './validate.js';
-import {createPropertyExpression} from '../expression/index.js';
+import type {ValidationOptions} from './validate';
+import {createPropertyExpression} from '../expression/index';
 
 export type PropertyValidationOptions = ValidationOptions & {
     objectKey: string;
     layerType: string;
-    layer: Object;
-}
+    layer: any;
+};
 
 export default function validateProperty(options: PropertyValidationOptions, propertyType: string): Array<ValidationError> {
     const key = options.key;
@@ -44,7 +42,8 @@ export default function validateProperty(options: PropertyValidationOptions, pro
         return [new ValidationWarning(key, value, `unknown property "${propertyKey}"`)];
     }
 
-    let tokenMatch: ?RegExp$matchResult;
+    // @ts-expect-error - TS2702 - 'RegExp' only refers to a type, but is being used as a namespace here.
+    let tokenMatch: RegExp.matchResult | null | undefined;
     if (getType(value) === 'string' && supportsPropertyExpression(valueSpec) && !valueSpec.tokens && (tokenMatch = /^{([^}]+)}$/.exec(value))) {
         const example = `\`{ "type": "identity", "property": ${tokenMatch ? JSON.stringify(tokenMatch[1]) : '"_"'} }\``;
         return [new ValidationError(
@@ -66,7 +65,7 @@ export default function validateProperty(options: PropertyValidationOptions, pro
         if (supportsPropertyExpression(valueSpec) && (supportsLightExpression(valueSpec) || supportsZoomExpression(valueSpec))) {
             // Performance related style spec limitation: zoom and light expressions are not allowed for e.g. trees.
             const expression = createPropertyExpression(deepUnbundle(value), valueSpec);
-            const expressionObj = (expression.value: any).expression || (expression.value: any)._styleExpression.expression;
+            const expressionObj = (expression.value as any).expression || (expression.value as any)._styleExpression.expression;
 
             if (expressionObj && !isGlobalPropertyConstant(expressionObj, ['measure-light'])) {
                 if (propertyKey !== 'model-emissive-strength' || (!isFeatureConstant(expressionObj) || !isStateConstant(expressionObj))) {
@@ -82,6 +81,7 @@ export default function validateProperty(options: PropertyValidationOptions, pro
         valueSpec,
         style,
         styleSpec,
+        // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'expressionContext' does not exist in type 'ValidationOptions'.
         expressionContext: 'property',
         propertyType,
         propertyKey

package/validate/{validate_source.js → validate_source.ts}

@@ -1,15 +1,13 @@
-// @flow
+import {default as ValidationError, ValidationWarning} from '../error/validation_error';
+import {unbundle} from '../util/unbundle_jsonlint';
+import validateObject from './validate_object';
+import validateEnum from './validate_enum';
+import validateExpression from './validate_expression';
+import validateString from './validate_string';
+import getType from '../util/get_type';
 
-import {default as ValidationError, ValidationWarning} from '../error/validation_error.js';
-import {unbundle} from '../util/unbundle_jsonlint.js';
-import validateObject from './validate_object.js';
-import validateEnum from './validate_enum.js';
-import validateExpression from './validate_expression.js';
-import validateString from './validate_string.js';
-import getType from '../util/get_type.js';
-
-import type {StyleReference} from '../reference/latest.js';
-import type {ValidationOptions} from './validate.js';
+import type {StyleReference} from '../reference/latest';
+import type {ValidationOptions} from './validate';
 
 const objectElementValidators = {
     promoteId: validatePromoteId
@@ -28,6 +26,7 @@ export default function validateSource(options: ValidationOptions): Array<Valida
     const type = unbundle(value.type);
     let errors = [];
 
+    // @ts-expect-error - TS2345 - Argument of type 'unknown' is not assignable to parameter of type 'string'.
     if (['vector', 'raster', 'raster-dem', 'raster-array'].includes(type)) {
         if (!value.url && !value.tiles) {
             errors.push(new ValidationWarning(key, value, 'Either "url" or "tiles" is required.'));
@@ -110,7 +109,8 @@ export default function validateSource(options: ValidationOptions): Array<Valida
 }
 
 function getSourceTypeValues(styleSpec: StyleReference) {
-    return styleSpec.source.reduce((memo, source) => {
+// @ts-expect-error - TS2347 - Untyped function calls may not accept type arguments.
+    return styleSpec.source.reduce<Array<any>>((memo, source) => {
         const sourceType = styleSpec[source];
         if (sourceType.type.type === 'enum') {
             memo = memo.concat(Object.keys(sourceType.type.values));
@@ -119,7 +119,10 @@ function getSourceTypeValues(styleSpec: StyleReference) {
     }, []);
 }
 
-function validatePromoteId({key, value}: $Shape<ValidationOptions>) {
+function validatePromoteId({
+    key,
+    value,
+}: Partial<ValidationOptions>) {
     if (getType(value) === 'string') {
         return validateString({key, value});
     } else {

package/validate/validate_string.ts

@@ -0,0 +1,16 @@
+import getType from '../util/get_type';
+import ValidationError from '../error/validation_error';
+
+import type {ValidationOptions} from './validate';
+
+export default function validateString(options: Partial<ValidationOptions>): Array<ValidationError> {
+    const value = options.value;
+    const key = options.key;
+    const type = getType(value);
+
+    if (type !== 'string') {
+        return [new ValidationError(key, value, `string expected, ${type} found`)];
+    }
+
+    return [];
+}

package/validate/validate_style.ts

@@ -0,0 +1,33 @@
+import validate from './validate';
+import latestStyleSpec from '../reference/latest';
+import validateGlyphsURL from './validate_glyphs_url';
+
+import ValidationError from '../error/validation_error';
+
+import type {ValidationOptions} from './validate';
+import type {StyleSpecification} from '../types';
+
+type StyleValidationOptions = {
+    key?: ValidationOptions['key'];
+};
+
+export default function validateStyle(
+    style: StyleSpecification,
+    styleSpec: any = latestStyleSpec,
+    options: StyleValidationOptions = {},
+): ValidationError[] {
+    const errors = validate({
+        key: options.key || '',
+        value: style,
+        valueSpec: styleSpec.$root,
+        styleSpec,
+        style,
+        // @ts-expect-error - TS2353 - Object literal may only specify known properties, and 'objectElementValidators' does not exist in type 'ValidationOptions'.
+        objectElementValidators: {
+            glyphs: validateGlyphsURL,
+            '*': () => []
+        }
+    });
+
+    return errors;
+}

package/validate/{validate_terrain.js → validate_terrain.ts}

@@ -1,11 +1,9 @@
-// @flow
+import {default as ValidationError, ValidationWarning} from '../error/validation_error';
+import validate from './validate';
+import getType from '../util/get_type';
+import {unbundle} from '../util/unbundle_jsonlint';
 
-import {default as ValidationError, ValidationWarning} from '../error/validation_error.js';
-import validate from './validate.js';
-import getType from '../util/get_type.js';
-import {unbundle} from '../util/unbundle_jsonlint.js';
-
-import type {ValidationOptions} from './validate.js';
+import type {ValidationOptions} from './validate';
 
 export default function validateTerrain(options: ValidationOptions): Array<ValidationError> {
     const terrain = options.value;

package/{validate_mapbox_api_supported.js → validate_mapbox_api_supported.ts}

@@ -1,22 +1,20 @@
-// @flow
+import {validateStyle} from './validate_style.min';
+import {v8} from './style-spec';
+import readStyle from './read_style';
+import ValidationError from './error/validation_error';
+import getType from './util/get_type';
 
-import {validateStyle} from './validate_style.min.js';
-import {v8} from './style-spec.js';
-import readStyle from './read_style.js';
-import ValidationError from './error/validation_error.js';
-import getType from './util/get_type.js';
-
-import type {ValidationErrors} from './validate_style.min.js';
+import type {ValidationErrors} from './validate_style.min';
 
 const SUPPORTED_SPEC_VERSION = 8;
 const MAX_SOURCES_IN_STYLE = 15;
 
-function isValid(value: ?string, regex: RegExp): boolean {
+function isValid(value: string | null | undefined, regex: RegExp): boolean {
     if (!value || getType(value) !== 'string') return true;
     return !!value.match(regex);
 }
 
-function getSourceCount(source: Object): number {
+function getSourceCount(source: any): number {
     if (source.url) {
         return source.url.split(',').length;
     } else {
@@ -24,7 +22,7 @@ function getSourceCount(source: Object): number {
     }
 }
 
-function getAllowedKeyErrors(obj: Object, keys: Array<*>, path: ?string): Array<ValidationError> {
+function getAllowedKeyErrors(obj: any, keys: Array<any>, path?: string | null): Array<ValidationError> {
     const allowed = new Set(keys);
     const errors = [];
     Object.keys(obj).forEach(k => {
@@ -37,7 +35,7 @@ function getAllowedKeyErrors(obj: Object, keys: Array<*>, path: ?string): Array<
 }
 
 const acceptedSourceTypes = new Set(["vector", "raster", "raster-dem", "raster-array", "model", "batched-model"]);
-function getSourceErrors(source: Object, i: number): Array<ValidationError> {
+function getSourceErrors(source: any, i: number): Array<ValidationError> {
     const errors = [];
 
     /*
@@ -76,7 +74,10 @@ function getMaxSourcesErrors(sourcesCount: number): Array<ValidationError> {
     return errors;
 }
 
-function getSourcesErrors(sources: Object): {errors: Array<ValidationError>, sourcesCount: number} {
+function getSourcesErrors(sources: any): {
+    errors: Array<ValidationError>;
+    sourcesCount: number;
+} {
     const errors = [];
     let sourcesCount = 0;
 
@@ -94,11 +95,14 @@ function getSourcesErrors(sources: Object): {errors: Array<ValidationError>, sou
     return {errors, sourcesCount};
 }
 
-function getImportErrors(imports: Array<Object> = []): {errors: Array<ValidationError>, sourcesCount: number} {
+function getImportErrors(imports: Array<any> = []): {
+    errors: Array<ValidationError>;
+    sourcesCount: number;
+} {
     let errors: Array<ValidationError> = [];
 
     let sourcesCount = 0;
-    const validateImports = (imports: Array<Object> = []) => {
+    const validateImports = (imports: Array<any> = []) => {
         for (const importSpec of imports) {
             const style = importSpec.data;
             if (!style) continue;
@@ -125,7 +129,7 @@ function getImportErrors(imports: Array<Object> = []): {errors: Array<Validation
     return {errors, sourcesCount};
 }
 
-function getRootErrors(style: Object, specKeys: Array<any>): Array<ValidationError> {
+function getRootErrors(style: any, specKeys: Array<any>): Array<ValidationError> {
     const errors = [];
 
     /*
@@ -204,11 +208,11 @@ function getRootErrors(style: Object, specKeys: Array<any>): Array<ValidationErr
  *   var validateMapboxApiSupported = require('mapbox-gl-style-spec/lib/validate_style_mapbox_api_supported.js');
  *   var errors = validateMapboxApiSupported(style);
  */
-export default function validateMapboxApiSupported(style: Object, styleSpec: Object = v8): ValidationErrors {
+export default function validateMapboxApiSupported(style: any, styleSpec: any = v8): ValidationErrors {
     let s = style;
     try {
         s = readStyle(s);
-    } catch (e) {
+    } catch (e: any) {
         return [e];
     }