@cyclomedia/streetsmart-api 23.14.4 → 23.14.5

package/index.d.ts

@@ -1,80 +1,573 @@
+/// <reference path="./src/types/shared.d.ts" />
 declare module '@cyclomedia/streetsmart-api' {
-    export interface ApiOptions {
-        targetElement: HTMLElement | null;
-        username?: string;
-        password?: string;
-        loginOauth?: boolean;
-        clientId?: string;
-        loginRedirectUri?: string;
-        logoutRedirectUri?: string;
-        tid?: string;
+    type Locale = 'de' | 'en-GB' | 'en-US' | 'fi' | 'fr' | 'nl' | 'tr';
+
+    type EventType =
+        | MeasurementEvents
+        | PanoramaViewerEvents
+        | ObliqueViewerEvents
+        | MeshViewerEvents
+        | PointCloudViewerEvents;
+
+    type Viewer = MeshViewerContainer | PanoramaViewer | ObliqueViewer | PointCloudViewer;
+
+    type GlobalEventCallback<T extends GlobalViewerEvents | MeasurementEvents> = (
+        event: GlobalEvent[T],
+    ) => StreetSmartApi;
+
+    interface GlobalEvent {
+        [GlobalViewerEvents.VIEWER_ADDED]: ViewerEvent<{ viewer: Viewer }>;
+        [GlobalViewerEvents.VIEWER_UPDATED]: ViewerEvent<{ viewer: Viewer }>;
+        [GlobalViewerEvents.VIEWER_REMOVED]: ViewerEvent<{ viewer: Viewer }>;
+        [MeasurementEvents.MEASUREMENT_STARTED]: ViewerEvent<
+            MeasurementEventDetails[MeasurementEvents.MEASUREMENT_STARTED]
+        >;
+        [MeasurementEvents.MEASUREMENT_STOPPED]: ViewerEvent<
+            MeasurementEventDetails[MeasurementEvents.MEASUREMENT_STOPPED]
+        >;
+        [MeasurementEvents.MEASUREMENT_CHANGED]: ViewerEvent<
+            MeasurementEventDetails[MeasurementEvents.MEASUREMENT_CHANGED]
+        >;
+        [MeasurementEvents.MEASUREMENT_SAVED]: ViewerEvent<
+            MeasurementEventDetails[MeasurementEvents.MEASUREMENT_SAVED]
+        >;
+    }
+
+    enum RecordingService {
+        DCR = 'DCR',
+        THIRD_PARTY = 'TP',
+    }
+
+    interface ApiOptionsBase {
+        // DOM element to render the viewers into.
+        targetElement: HTMLElement;
         apiKey: string;
+        // Indicates whether to login using OAuth
+        // EPSG code of the coordinate system used in the API. E.g. "EPSG:28992".
         srs: string;
-        locale?: string;
+        // Language used as default in the API. <br /> Default is 'en-US'
+        locale?: Locale;
+        // Max distance that is used for draw the overlays in the panorama viewer. <br />Default is 30m
         overlayDrawDistance?: number;
+        /*
+            Alternate configuration url to use for all configuration services.
+            Can be used for a {@link http://localinstallation.cyclomedia.com|local installation}.
+         */
         configurationUrl?: string;
-        staticBaseUrl?: string;
+        // The address settings to use for address searches.
         addressSettings?: {
+            // The locale to use. e.g. 'nl', use only 2 letter {@link https://www.iso.org/iso-3166-country-codes.html ISO-3166} {@link https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2 country codes}.
             locale: string;
+            // The name of the database. e.g. 'CMDatabase'.
             database: string;
         };
     }
 
+    interface BasicAuthOptions {
+        username: string;
+        password: string;
+        tid?: string;
+    }
+
+    interface OAuthOptions {
+        // The clientId can be obtained from the helpdesk.
+        clientId: string;
+        // The absolute / relative path to the endpoint that handles **login** redirects from OAuth
+        loginRedirectUri: string;
+        // The absolute / relative path to the endpoint that handles **logout** redirects from OAuth
+        logoutRedirectUri: string;
+    }
+
+    export type AuthOptions = ({ loginOauth: false } & BasicAuthOptions) | ({ loginOauth: true } & OAuthOptions);
+
+    export type ApiOptions = ApiOptionsBase & AuthOptions;
+
     type OpenViewerQuery =
         | string
         | number[]
         | {
-              coordinates: number[];
+              coordinate: number[];
+              // Date range only works for ViewerType.PANORAMA
               dateRange?: {
                   from: string;
                   to: string;
               };
           };
 
+    type PanoramaViewerOptions = Partial<{
+        /**
+         * Show window close button. Default is true.
+         */
+        closable: boolean;
+
+        /**
+         * Show window maximize button. Default is true.
+         */
+        maximizable: boolean;
+
+        /**
+         * Replace already opened panorama viewer.
+         */
+        replace: boolean;
+
+        /**
+         * Show recording dots.
+         */
+        recordingsVisible: boolean;
+
+        /**
+         * Enable viewing earlier recordings.
+         */
+        timeTravelVisible: boolean;
+
+        /**
+         * Show viewer navigation bar.
+         */
+        navbarVisible: boolean;
+
+        /**
+         * Show viewer sidebar.
+         */
+        sidebarVisible: boolean;
+
+        /**
+         * Show measurement type button in measurement navigation bar. Default is true.
+         */
+        measureTypeButtonVisible: boolean;
+
+        /**
+         * Allow toggle of measurement type in measurement navigation bar. Default is true.
+         */
+        measureTypeButtonToggle: boolean;
+
+        /**
+         * Start new measurement when clicking on measurement type button in measurement navigation bar. Default is true.
+         */
+        measureTypeButtonStart: boolean;
+    }>;
+
+    type ObliqueViewerOptions = Partial<{
+        /**
+         * Show window close button. Default is true.
+         */
+        closable: boolean;
+
+        /**
+         * Show window maximize button. Default is true.
+         */
+        maximizable: boolean;
+
+        /**
+         * Enable viewing earlier oblique images.
+         */
+        timeTravelVisible: boolean;
+
+        /**
+         * Show viewer navigation bar.
+         */
+        navbarVisible: boolean;
+
+        /**
+         * Show viewer sidebar.
+         */
+        sidebarVisible: boolean;
+    }>;
+
+    interface PointcloudViewerOptions {
+        /**
+         * Type of point cloud to open.
+         */
+        pointCloudType: PointCloudType;
+    }
+
+    interface MeshViewerOptions {
+        /**
+         * Determines how the camera is set when opening the viewer (e.g., OBLIQUE -> bird's view, PANORAMA -> streetview, etc.).
+         */
+        fromViewer: ViewerType;
+    }
+
     interface OpenViewerOptions {
-        viewerType: [string] | string;
+        // Provide viewer type or multiple viewer types in array to open multiple viewers.
+        viewerType: ViewerType[] | ViewerType;
+        // EPSG code of the spatial reference system to use
         srs: string;
-        panoramaViewer?: any;
-        obliqueViewer?: any;
-        pointcloudViewer?: any;
-        meshviewer?: any;
+        // Value indicating what kind of service to open
+        recordingServiceType?: RecordingService;
+        panoramaViewer?: PanoramaViewerOptions;
+        obliqueViewer?: ObliqueViewerOptions;
+        pointcloudViewer?: PointcloudViewerOptions;
+        meshviewer?: MeshViewerOptions;
+    }
+
+    type Credentials = {
+        username: string;
+        password: string;
+    };
+
+    enum MeasureMethods {
+        MEASURE_SMART = 'DepthMap',
+        SMART_CLICK = 'SmartClick',
+        FORWARD_INTERSECTION = 'ForwardIntersection',
     }
 
-    export function init(options: ApiOptions): Promise<any>;
+    enum MeasurementGeometryTypes {
+        POINT = 'Point',
+        LINESTRING = 'LineString',
+        POLYGON = 'Polygon',
+        ORTHOGONAL = 'Orthogonal',
+        HEIGHT = 'Height',
+    }
+
+    class StreetSmartApi {
+        static init(options: ApiOptions): Promise<void>;
+
+        /**
+         * Open a panorama, oblique, point cloud viewer and/or meshviewer using a query. The query can be a coordinate, an extent, an address or a panorama/oblique ID.
+         * @param {string} query - The query<p/>
+         * <ul>
+         * <li>Coordinate: x,y E.g. <code>'86580,437038'</code></li>
+         * <li>Extent: minx,miny,maxx,maxy E.g. <code>'86580,437038,86880,437338'</code></li>
+         * <li>Address: E.g. <code>'Domplein, Utrecht'</code></li>
+         * <li>Panorama ID: E.g. <code>'5D4KX5SM'</code></li>
+         * <li>Oblique ID: E.g. <code>'014_0849_00135489_NOB16'</code></li>
+         * </ul>
+         * @param {object} options
+         * @param  options.viewerType - an array indicating what kind of viewer(s) to open
+         * @param  options.recordingServiceType - value indicating what kind of service to open
+         * @param  options.srs - EPSG code of the spatial reference system to use
+         * @param  options.panoramaViewer - options object for PanoramaViewer options
+         * @param  options.obliqueViewer - options object for ObliqueViewer options
+         * @param  options.pointcloudViewer - options object for PointcloudViewer options
+         * @param  options.meshviewer - options object for MeshViewer options
+         * @returns  When the promise resolves, it returns an array with references to the created {@link PanoramaViewer}, {@link ObliqueViewer}, {@link PointCloudViewer} and/or {@link MeshViewerContainer}.
+         * @example <caption>Open a panorama viewer by ID:</caption>
+         * StreetSmartApi.open('5D4KX5SM', {
+         *   viewerType: [StreetSmartApi.ViewerType.PANORAMA],
+         *   srs: 'EPSG:28992',
+         *   panoramaViewer: { replace: false, },
+         * }).then(
+         *   function(result) {
+         *     if (result && result[0]) {
+         *       console.log('Opened a panorama viewer through API!', result[0]);
+         *     }
+         *   }
+         * ).catch(
+         *   function(reason) {
+         *     console.log('Error opening panorama viewer: ' + reason);
+         *   }
+         * )
+         * @example <caption>Open a panorama viewer by coordinate and date range (this is only applicable for the panorama viewer):</caption>
+         * StreetSmartApi.open(
+         * {
+         *  coordinate: [121692.34, 487812.37, 5.60],
+         *  dateRange: {from: '2017-03-01', to: '2017-04-01'},
+         * },
+         * {
+         * viewerType: [StreetSmartApi.ViewerType.PANORAMA],
+         * srs: 'EPSG:28992',
+         * panoramaViewer: { replace: false, },
+         * }).then(
+         *   function(result) {
+         *     if (result && result[0]) {
+         *       console.log('Opened a panorama viewer through API!', result[0]);
+         *     }
+         *   }
+         * ).catch(
+         *   function(reason) {
+         *     console.log('Error opening panorama viewer: ' + reason);
+         *   }
+         * )
+         * @example <caption>Open a panorama viewer and oblique viewer by address:</caption>
+         * StreetSmartApi.open('Van Voordenpark 1, Zaltbommel', {
+         *   viewerType: [StreetSmartApi.ViewerType.PANORAMA, StreetSmartApi.ViewerType.OBLIQUE],
+         *   srs: 'EPSG:28992',
+         * }).then(
+         *   function(result) {
+         *     if (result && result[0] && result[1]) {
+         *       console.log('Opened a panorama viewer and oblique viewer through API!', result[0], result[1]);
+         *     }
+         *   }
+         * ).catch(
+         *   function(reason) {
+         *     console.log('Error opening viewers: ' + reason);
+         *   }
+         * )
+         * @example <caption>Open a aerial pointcloud viewer by coordinate:</caption>
+         * StreetSmartApi.open(
+         * {
+         *   coordinate: [121692.34, 487812.37, 5.60],
+         * },
+         * {
+         *   viewerType: [StreetSmartApi.ViewerType.POINTCLOUD],
+         *   srs: 'EPSG:28992',
+         *   pointcloudViewer: { pointCloudType: StreetSmartApi.PointCloudType.AERIAL }}).then(
+         *   function(result) {
+         *     if (result && result[0]) {
+         *       console.log('Opened a pointcloud viewer through API!', result[0]);
+         *     }
+         *   }
+         * ).catch(
+         *   function(reason) {
+         *     console.log('Error opening pointcloud viewer: ' + reason);
+         *   }
+         * )
+         * @example <caption>Open a panorama viewer and an aerial pointcloud viewer by coordinate:</caption>
+         * StreetSmartApi.open(
+         * {
+         *   coordinate: [121692.34, 487812.37, 5.60],
+         * },
+         * {
+         *   viewerType: [StreetSmartApi.ViewerType.PANORAMA, StreetSmartApi.ViewerType.POINTCLOUD],
+         *   srs: 'EPSG:28992',
+         *   panoramaViewer: { replace: false, },
+         *   pointcloudViewer: { pointCloudType: StreetSmartApi.PointCloudType.AERIAL }}).then(
+         *   function(result) {
+         *     if (result) {
+         *       console.log('Opened a pointcloud viewer and a panorama viewer through API!', result);
+         *     }
+         *   }
+         * ).catch(
+         *   function(reason) {
+         *     console.log('Error opening pointcloud viewer and panorama viewer: ' + reason);
+         *   }
+         * )
+         * @example <caption>Open a meshviewer by coordinates:</caption>
+         * StreetSmartApi.open(
+         * {
+         *   coordinate: [121293.08, 487400, 69],
+         * },
+         * {
+         *   viewerType: StreetSmartApi.ViewerType.MESHVIEWER,
+         *   srs: 'EPSG:28992',
+         *   meshviewer: {
+         *     fromViewer: StreetSmartApi.ViewerType.PANORAMA,
+         *   }
+         *  }).then(
+         *   function(result) {
+         *     if (result) {
+         *       console.log('Opened a meshviewer through the API', result);
+         *     }
+         *   }
+         * ).catch(
+         *   function(reason) {
+         *     console.log('Error opening meshviewer: ' + reason);
+         *   }
+         * )
+         * @example <caption>Open a meshviewer by imageID or address: (choose one)</caption>
+         * StreetSmartApi.open("WE4UGIO7" || "Dam 3, Amsterdam",
+         * {
+         *   viewerType: StreetSmartApi.ViewerType.MESHVIEWER,
+         *   srs: 'EPSG:28992',
+         *   meshviewer: {
+         *     fromViewer: StreetSmartApi.ViewerType.PANORAMA,
+         *   }
+         *  }).then(
+         *   function(result) {
+         *     if (result) {
+         *       console.log('Opened a meshviewer through the API', result);
+         *     }
+         *   }
+         * ).catch(
+         *   function(reason) {
+         *     console.log('Error opening meshviewer: ' + reason);
+         *   }
+         * )
+         */
+        static open(query: OpenViewerQuery, options: OpenViewerOptions): Promise<Viewer[]>;
 
-    export function open(query: OpenViewerQuery, options: OpenViewerOptions): Promise<any>;
+        static destroy(options: { targetElement: HTMLElement; loginOauth: boolean }): Promise<void>;
 
-    export function destroy(options: Pick<ApiOptions, 'targetElement' | 'loginOauth'>): void;
+        static getAddressSettings(): { locale: string; database: string };
 
-    export function destroy(options: { targetElement: Element; loginOauth: boolean }): Promise<void>;
+        static getApiReadyState(): boolean;
 
-    export function getApplicationName(): string;
+        static getApplicationName(): string;
 
-    export function getApplicationVersion(): string;
+        static getApplicationVersion(): string;
 
-    export function getPermissions(): string[];
+        static getDebugLogs(): string[];
 
-    export function getAddressSettings(): { locale: string; database: string };
+        static getPermissions(): string[];
 
-    export function setAddressSettings(addressSettings: { locale: string; database: string }): void;
+        static getViewers(): Viewer[];
 
-    export function getDebugLogs(): string[];
+        /**
+         * @returns {Array|null} Returns an array that includes type, GeoJSON data, and CRS object. Returns `null` if there is no active measurement.
+         * @example
+         * // Get the active measurement data
+         * const result = StreetSmartApi.getActiveMeasurement();
+         */
+        static getActiveMeasurement(): MeasurementCollection | null;
 
-    export function on(type: string, callback: (event: Event) => void): void;
+        /**
+         * ** EXPERIMENTAL **
+         * Set the active measurement.
+         *
+         * @param {object} geojson - A GeoJSON FeatureCollection including a CRS object. See http://geojson.org/geojson-spec#coordinate-reference-system-objects.
+         *
+         * @example
+         * // Set the active measurement data
+         * const measurement = StreetSmartApi.getActiveMeasurement();
+         *
+         * // Modify the measurement
+         * measurement.features[0].properties.id = 'changed_measurement';
+         *
+         * // Set the modified measurement
+         * StreetSmartApi.setActiveMeasurement(measurement)
+         */
+        static setActiveMeasurement(geojson: MeasurementCollection): void;
 
-    export function off(type: string, callback: (event: Event) => void): void;
+        /**
+         * Start measurement mode for the given panorama viewer.
+         *
+         * @param  viewer - An instance of {@link PanoramaViewer} or {@link ObliqueViewer}.
+         * @param {Object} [options] - Object containing measurement options.
+         * @param [options.geometry] - Bypasses the measurement mode dialog and starts measurement in the given mode.
+         * @param  [options.measureMethod] - Starts the measurement with a specified measurement method. MeasureSmart, SmartClick, or Forward Intersection. Only applicable to panorama measurements.
+         * @param  [options.showSaveMeasurementButton] - Show the 'Save measurement' button during the measurement. Note: With the button toggle: 'SAVE_MEASUREMENT' you can also enable the measurement button. You need this toggle if you want to start the measurement from the panorama viewer.
+         * @param  [options.recordingServiceType] - Type of recordings which will be used to perform measurements on. Defaults to RecordingSerivceType.DCR.
+         * @example <caption>Start measurement mode without passing a geometry type.
+         * The user can then choose the measurement mode.</caption>
+         * StreetSmartApi.startMeasurementMode(panoramaViewer);
+         * @example <caption>Start measurement mode as point measurement</caption>
+         * StreetSmartApi.startMeasurementMode(panoramaViewer, {geometry: StreetSmartApi.MeasurementGeometryType.POINT});
+         * @example <caption>Start measurement mode as distance measurement</caption>
+         * StreetSmartApi.startMeasurementMode(panoramaViewer, {geometry: StreetSmartApi.MeasurementGeometryType.LINESTRING});
+         * @example <caption>Start measurement mode as surface measurement</caption>
+         * StreetSmartApi.startMeasurementMode(panoramaViewer, {geometry: StreetSmartApi.MeasurementGeometryType.POLYGON});
+         * @example <caption>Start measurement mode as surface measurement, with a measure method Smart Click</caption>
+         * StreetSmartApi.startMeasurementMode(panoramaViewer, {geometry: StreetSmartApi.MeasurementGeometryType.POLYGON, measureMethod: StreetSmartApi.MeasureMethods.SMART_CLICK });
+         * @example <caption>Start measurement mode as surface measurement, with the show measurement button visible</caption>
+         * StreetSmartApi.startMeasurementMode(panoramaViewer, {geometry: StreetSmartApi.MeasurementGeometryType.POLYGON, showSaveMeasurementButton: true });
+         * @example <caption>Show the 'Save measurement' button during a measurement. The measurement can be started from the panorama viewer.</caption>
+         * StreetSmartApi.open('5D4KX5SM', {
+         *   viewerType: [StreetSmartApi.ViewerType.PANORAMA],
+         *   srs: 'EPSG:28992',
+         *   replace: false,
+         * }).then(
+         *   function(result) {
+         *     if (result && result[0]) {
+         *       const viewer = result[0];
+         *       viewer.toggleButtonEnabled(StreetSmartApi.PanoramaViewerUi.SAVE_MEASUREMENT);
+         *     }
+         *   }).catch(
+         *     function(reason) {
+         *       console.log('Error opening panorama viewer: ' + reason);
+         *     }
+         * )
+         */
+        static startMeasurementMode(
+            viewer: PanoramaViewer | ObliqueViewer,
+            options?: {
+                geometry?: MeasurementGeometryTypes;
+                measureMethod?: MeasureMethods;
+                showSaveMeasurementButton?: boolean;
+                recordingServiceType?: RecordingService;
+            },
+        ): void;
 
-    export function viewerAdded(viewer: any): void;
+        /**
+         * Stop measurement mode. */
+        static stopMeasurementMode(): void;
 
-    export function viewerRemoved(wid: any): void;
+        static on<T extends GlobalViewerEvents | MeasurementEvents>(
+            type: T,
+            callback: GlobalEventCallback<T>,
+        ): StreetSmartApi;
 
-    export function viewerUpdated(wid: any, oldViewer: any): void;
+        static off<T extends GlobalViewerEvents | MeasurementEvents>(
+            type: T,
+            callback: GlobalEventCallback<T>,
+        ): StreetSmartApi;
 
-    export function measurementSaved(measurement: any, wid: any): void;
+        /**
+         * Sets whether cursor movements will snap to nearby features while in measurement mode.
+         *
+         * @param {boolean} enabled - Whether to enable or disable snapping.
+         * @default false
+         */
+        static setSnapping(enabled: boolean): void;
 
-    export function measurementChanged(measurement: any, wid: any): void;
+        /**
+         * Sets the overlay draw distance.
+         *
+         * @param overlayDrawDistance - The distance value for overlay drawing.
+         * @example
+         * var layer = StreetSmartApi.addOverlay("My GeoJSON", {}, "EPSG:28992");
+         * StreetSmartApi.setOverlayDrawDistance(50);
+         */
+        static setOverlayDrawDistance(overlayDrawDistance: number): void;
 
-    export function measurementStarted(measurement: any, wid: any): void;
+        /**
+         * Add a GeoJSON overlay to the panorama viewer. Can be removed with {@link StreetSmartApi.removeOverlay}
+         * @example
+         * // Add Overlay
+         * const options = { name: 'My GeoJSON', geojson: {}, sourceSrs: 'EPSG:28992', sldXMLtext: 'XMLstring' };
+         * const layer = StreetSmartApi.addOverlay(options);
+         * const {id: layerId} = layer;
+         */
+        static addOverlay(options: {
+            geojson: object;
+            name?: string;
+            sourceSrs?: string;
+            sldXMLtext?: string;
+            color?: string;
+            visible?: boolean;
+        }): { id: string };
 
-    export function measurementStopped(measurement: any, wid: any): void;
+        /**
+         * Remove a GeoJSON overlay from the panorama viewer
+         * @param layerId - Id of the layer. Use the id that was returned by {@link StreetSmartApi.addOverlay}
+         * @example
+         * // Add Overlay
+         * const layer = StreetSmartApi.addOverlay({ name: 'My GeoJSON', geojson: {}, sourceSrs: 'EPSG:28992' });
+         * // Remove Overlay
+         * StreetSmartApi.removeOverlay(layer.id);
+         */
+        static removeOverlay(layerId: string): void;
+
+        /**
+         * Add a WFS Layer as an overlay to the panorama viewer. Can be removed with {@link removeOverlay}
+         *
+         * @param {Object} options - Set of parameters for overlay
+         * @param {string} options.name - Name of the layer
+         * @param {string} options.url - The URL where the WFS is hosted. Not needed if a remoteOWS is provided in the SLD.
+         * @param {string} options.typeName - The type name of the layer. Not needed if a remoteOWS is provided in the SLD.
+         * @param {string} options.version - The WFS version to be used
+         * @param {string} [options.sldXMLtext] - Optional XML string for Styled Layer Descriptor, this can contain a remoteOWS with WFS service.
+         * @param {string} [options.color] - Optional color string, needs to be a hexadecimal string value
+         * @param {boolean} [options.authRequired] - Whether this layer requires authentication to access
+         * @param {credentials} [options.credentials] - Credentials used to access the layer.
+         * @param {boolean} [options.visible] - Optional for setting the visibility of the layer, default is true
+         *
+         * @example
+         * // Add WFS layer
+         * var options = {
+         *     name: 'My Super cool layer',
+         *     url: 'http://testserver.com/geoserver/streets/wfs',
+         *     typeName: 'streets:street-center-lines',
+         *     version: '1.1.0',
+         *     color: '#00ff00',
+         *     authRequired: true,
+         *     credentials: { username: 'Mike', password: 'Tyson'}
+         * };
+         * var layer = StreetSmartApi.addWFSLayer(options);
+         * var layerId = layer.id;
+         *
+         * @returns {{id: string}}
+         */
+        static addWFSLayer(options: {
+            name: string;
+            url: string;
+            typeName: string;
+            version: string;
+            sldXMLtext?: string;
+            color?: string;
+            authRequired?: boolean;
+            credentials?: Credentials;
+            visible?: boolean;
+            customLayerType?: string;
+        }): { id: string };
+    }
 }

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@cyclomedia/streetsmart-api",
-  "version": "23.14.4",
+  "version": "23.14.5",
   "description": "The Streetsmart API wrapped as a npm package",
   "scripts": {
     "build": "scripts/build.sh",
     "rollup": "rollup -c",
     "docs": "npx typedoc --out docs src --theme minimal",
-    "test": "jest",
-    "prepublishOnly": "npm run build && npm run test && npm version patch",
-    "postpublish": "git add . && git commit -m 'Patch update' && git push"
+    "test": "jest"
   },
   "repository": {
     "type": "git",
@@ -29,23 +27,22 @@
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-replace": "^5.0.5",
     "@rollup/plugin-typescript": "^11.1.5",
-    "@rollup/rollup-darwin-arm64": "^4.1.4",
+    "@rollup/wasm-node": "^4.9.2",
     "@types/jest": "^29.5.7",
     "jest": "^29.7.0",
-    "rollup": "^4.1.4",
+    "rollup": "^4.9.2",
     "ts-jest": "^29.1.1",
+    "type-fest": "^4.8.3",
     "typedoc": "^0.25.2",
     "typescript": "^5.2.2"
   },
   "module": "dist/esm/index.js",
-  "exports": {
-    ".": {
-      "default": "./dist/esm/index.js"
-    }
-  },
+  "main": "./dist/esm/index.js",
   "files": [
     "dist",
-    "index.d.ts"
+    "index.d.ts",
+    "README.md",
+    "src/types/*"
   ],
-  "typings": "index.d.ts"
+  "types": "index.d.ts"
 }