@uwrl/qc-utils 0.0.14 → 0.0.17

package/dist/services/api.d.ts

@@ -0,0 +1,147 @@
+import { Unit, Thing, Sensor, ResultQualifier, ProcessingLevel, ObservedProperty, Datastream, Tag, PostHydroShareArchive, HydroShareArchive, User, Workspace, ApiKey } from '@/types';
+import { DataSource } from '@/models';
+import { OrchestrationSystem } from '@/models/dataSource';
+export declare const BASE_URL: string;
+export declare const AUTH_BASE: string;
+export declare const ACCOUNT_BASE: string;
+export declare const SESSION_BASE: string;
+export declare const PROVIDER_BASE: string;
+export declare const THINGS_BASE: string;
+export declare const TAG_BASE: string;
+type DatastreamFilterKey = 'unit_id' | 'sensor_id' | 'observed_property_id' | 'processing_level_id' | 'result_qualifier_id';
+export declare const getObservationsEndpoint: (id: string, pageSize: number, startTime: string, endTime?: string, page?: number) => string;
+export declare const api: {
+    fetchSession: () => Promise<any>;
+    login: (email: string, password: string) => Promise<any>;
+    logout: () => Promise<any>;
+    fetchUser: () => Promise<any>;
+    signup: (user: User) => Promise<any>;
+    updateUser: (user: User, oldUser: User) => Promise<any>;
+    deleteUser: () => Promise<any>;
+    sendVerificationEmail: (email: string) => Promise<any>;
+    verifyEmailWithCode: (key: string) => Promise<any>;
+    requestPasswordReset: (email: string) => Promise<any>;
+    resetPassword: (key: string, password: string) => Promise<any>;
+    fetchWorkspaces: () => Promise<any>;
+    fetchAssociatedWorkspaces: () => Promise<any>;
+    fetchWorkspace: (id: string) => Promise<any>;
+    createWorkspace: (postWorkspace: Workspace) => Promise<any>;
+    updateWorkspace: (newWorkspace: Workspace, oldWorkspace?: Workspace | null) => Promise<any>;
+    deleteWorkspace: (id: string) => Promise<any>;
+    transferWorkspace: (id: string, newOwner: string) => Promise<any>;
+    acceptWorkspaceTransfer: (id: string) => Promise<any>;
+    rejectWorkspaceTransfer: (id: string) => Promise<any>;
+    getCollaboratorRoles: (id: string) => Promise<any>;
+    getAPIKeyRoles: (id: string) => Promise<any>;
+    getRole: (roleId: string) => Promise<any>;
+    getCollaborators: (id: string) => Promise<any>;
+    addCollaborator: (id: string, email: string, roleId: string) => Promise<any>;
+    updateCollaboratorRole: (id: string, email: string, roleId: string) => Promise<any>;
+    removeCollaborator: (id: string, email: string) => Promise<any>;
+    fetchApiKeys: (workspaceId: string) => Promise<any>;
+    fetchApiKey: (workspaceId: string, apiKeyId: string) => Promise<any>;
+    createApiKey: (apiKey: ApiKey) => Promise<any>;
+    updateApiKey: (newKey: ApiKey, oldKey?: ApiKey) => Promise<any>;
+    regenerateApiKey: (id: string, apiKeyId: string) => Promise<any>;
+    deleteApiKey: (id: string, apiKeyId: string) => Promise<any>;
+    fetchConnectedProviders: () => Promise<any>;
+    providerRedirect: (provider: string, callbackUrl: string, process: string) => void;
+    providerSignup: (user: User) => Promise<any>;
+    deleteProvider: (provider: string, account: string) => Promise<any>;
+    createUnit: (unit: Unit) => Promise<any>;
+    fetchUnits: () => Promise<any>;
+    fetchWorkspaceUnits: (id: string) => Promise<any>;
+    updateUnit: (newUnit: Unit, oldUnit?: Unit | null) => Promise<any>;
+    deleteUnit: (id: string) => Promise<any>;
+    getUnit: (id: string) => Promise<any>;
+    removeThingOwner: (id: string, email: string) => Promise<any>;
+    addSecondaryOwner: (id: string, email: string) => Promise<any>;
+    transferPrimaryOwnership: (id: string, email: string) => Promise<any>;
+    createThing: (thing: Thing) => Promise<any>;
+    fetchThings: () => Promise<any>;
+    fetchThingsForWorkspace: (id: string) => Promise<any>;
+    fetchOwnedThings: () => Promise<any>;
+    fetchThing: (id: string) => Promise<any>;
+    updateThing: (thing: Thing) => Promise<any>;
+    updateThingPrivacy: (id: string, isPrivate: boolean) => Promise<any>;
+    deleteThing: (id: string) => Promise<any>;
+    fetchMetadataForThingOwner: (thingId: string) => Promise<any>;
+    fetchMetadataForThing: (thingId: string) => Promise<any>;
+    uploadSitePhotos: (thingId: string, data: FormData) => Promise<any>;
+    fetchSitePhotos: (thingId: string) => Promise<any>;
+    deleteSitePhoto: (thingId: string, name: string) => Promise<any>;
+    createSiteTag: (thingId: string, tag: Tag) => Promise<any>;
+    editSiteTag: (thingId: string, tag: Tag) => Promise<any>;
+    fetchSiteTags: (thingId: string) => Promise<any>;
+    fetchUsersSiteTags: () => Promise<any>;
+    deleteSiteTag: (thingId: string, tag: Tag) => Promise<any>;
+    fetchWorkspaceTags: (workspaceId: string) => Promise<any>;
+    createHydroShareArchive: (archive: PostHydroShareArchive) => Promise<any>;
+    updateHydroShareArchive: (newArchive: HydroShareArchive, oldArchive?: HydroShareArchive) => Promise<any>;
+    fetchHydroShareArchive: (thingId: string) => Promise<any>;
+    deleteHydroShareArchive: (thingId: string) => Promise<any>;
+    archiveToHydroShare: (thingId: string) => Promise<any>;
+    createDatastream: (datastream: Datastream) => Promise<any>;
+    fetchDatastreams: (filters?: Partial<Record<DatastreamFilterKey, string>>) => Promise<any>;
+    fetchDatastreamsForThing: (thingId: string) => Promise<any>;
+    fetchExpandedDatastreamsForThing: (thingId: string) => Promise<any>;
+    fetchDatastreamsForDataSource: (id: string) => Promise<any>;
+    fetchDatastream: (id: string) => Promise<any>;
+    fetchDatastreamExpanded: (id: string) => Promise<any>;
+    fetchUsersDatastreams: () => Promise<any>;
+    updateDatastream: (newDS: Datastream, oldDS?: Datastream | null) => Promise<any>;
+    deleteDatastream: (id: string) => Promise<any>;
+    downloadDatastreamCSV: (id: string) => Promise<any>;
+    createObservedProperty: (op: ObservedProperty) => Promise<any>;
+    fetchObservedProperty: (id: string) => Promise<any>;
+    fetchObservedProperties: () => Promise<any>;
+    fetchWorkspaceObservedProperties: (id: string) => Promise<any>;
+    updateObservedProperty: (newOP: ObservedProperty, oldOP?: ObservedProperty | null) => Promise<any>;
+    deleteObservedProperty: (id: string) => Promise<any>;
+    createProcessingLevel: (pl: ProcessingLevel) => Promise<any>;
+    fetchProcessingLevels: () => Promise<any>;
+    fetchProcessingLevel: (id: string) => Promise<any>;
+    fetchWorkspaceProcessingLevels: (id: string) => Promise<any>;
+    updateProcessingLevel: (newPL: ProcessingLevel, oldPL?: ProcessingLevel | null) => Promise<any>;
+    deleteProcessingLevel: (id: string) => Promise<any>;
+    createSensor: (sensor: Sensor) => Promise<any>;
+    fetchSensors: () => Promise<any>;
+    fetchSensor: (id: string) => Promise<any>;
+    fetchWorkspaceSensors: (id: string) => Promise<any>;
+    updateSensor: (newSensor: Sensor, oldSensor?: Sensor | null) => Promise<any>;
+    deleteSensor: (id: string) => Promise<any>;
+    createResultQualifier: (resultQualifier: ResultQualifier) => Promise<any>;
+    fetchResultQualifiers: () => Promise<any>;
+    fetchWorkspaceResultQualifiers: (id: string) => Promise<any>;
+    updateResultQualifier: (newResultQualifier: ResultQualifier, oldResultQualifier?: ResultQualifier | null) => Promise<any>;
+    deleteResultQualifier: (id: string) => Promise<any>;
+    createOrchestrationSystem: (system: OrchestrationSystem) => Promise<any>;
+    fetchOrchestrationSystems: () => Promise<any>;
+    fetchWorkspaceOrchestrationSystems: (id: string) => Promise<any>;
+    fetchOrchestrationSystem: (id: string) => Promise<any>;
+    updateOrchestrationSystem: (id: string, system: OrchestrationSystem) => Promise<any>;
+    deleteOrchestrationSystem: (id: string) => Promise<any>;
+    createDataSource: (dataSource: DataSource) => Promise<any>;
+    fetchDataSources: () => Promise<any>;
+    fetchWorkspaceDataSources: (id: string) => Promise<any>;
+    fetchDataSource: (id: string) => Promise<any>;
+    updateDataSource: (newS: DataSource) => Promise<any>;
+    updateDataSourcePartial: (newS: DataSource) => Promise<any>;
+    deleteDataSource: (id: string) => Promise<any>;
+    linkDatastreamToDataSource: (dataSourceId: string, datastreamId: string) => Promise<any>;
+    unlinkDatastreamFromDataSource: (dataSourceId: string, datastreamId: string) => Promise<any>;
+    fetchObservations: (endpoint: string) => Promise<any>;
+    deleteObservationsForDatastream: (datastreamId: string) => Promise<any>;
+    fetchUserTypes: () => Promise<any>;
+    fetchOrganizationTypes: () => Promise<any>;
+    fetchSiteTypes: () => Promise<any>;
+    fetchSamplingFeatureTypes: () => Promise<any>;
+    fetchSensorEncodingTypes: () => Promise<any>;
+    fetchMethodTypes: () => Promise<any>;
+    fetchVariableTypes: () => Promise<any>;
+    fetchUnitTypes: () => Promise<any>;
+    fetchDatastreamStatuses: () => Promise<any>;
+    fetchDatastreamAggregations: () => Promise<any>;
+    fetchSampledMediums: () => Promise<any>;
+};
+export {};

package/dist/services/apiMethods.d.ts

@@ -0,0 +1,8 @@
+export declare const apiMethods: {
+    fetch(endpoint: string, options?: any): Promise<any>;
+    patch(endpoint: string, body: any, originalBody?: any, options?: any): Promise<any>;
+    post(endpoint: string, body?: any, options?: any): Promise<any>;
+    put(endpoint: string, body?: any, options?: any): Promise<any>;
+    delete(endpoint: string, body?: any, options?: any): Promise<any>;
+    paginatedFetch<T>(base: string, pageSize?: number): Promise<any>;
+};

package/dist/services/createPatchObject.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Creates an object that represents the differences (patches) between the
+ * original and the updated objects.
+ *
+ * This function iterates through the properties of the updated object and compares each property
+ * with the corresponding property in the original object. If a difference is found:
+ * 1. For properties that are objects, it recursively computes the nested differences.
+ * 2. For other properties, it directly assigns the updated value.
+ *
+ * Note: The function only checks properties that exist in the updated object.
+ *
+ * @param {any} original - The original object to compare from.
+ * @param {any} updated - The updated object to compare against.
+ * @returns {any} An object representing the differences between the two input objects.
+ *                If two properties are identical, they won't appear in the result.
+ */
+export declare function createPatchObject(original: any, updated: any): any;

package/dist/services/getCSRFToken.d.ts

@@ -0,0 +1 @@
+export declare function getCSRFToken(): string | null;

package/dist/services/index.d.ts

@@ -0,0 +1,6 @@
+export * from './api';
+export * from './apiMethods';
+export * from './createPatchObject';
+export * from './getCSRFToken';
+export * from './requestInterceptor';
+export * from './responseInterceptor';

package/dist/services/requestInterceptor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Intercepts and enhances a request options object.
+ *
+ * - Adds Django AllAuth 'sessionid' to all requests
+ * - Adds CSRF Token to non-GET requests
+ * - If a body is present and it's an object, the body is stringified.
+ *
+ * @param {any} options - The original request options object.
+ *
+ * @returns {any} The enhanced request options with possible modified headers and body.
+ */
+export declare function requestInterceptor(options: any): any;

package/dist/services/responseInterceptor.d.ts

@@ -0,0 +1,2 @@
+export declare function extractErrorMessage(body: any): any;
+export declare function responseInterceptor(response: Response): Promise<any>;

package/dist/types/index.d.ts

@@ -0,0 +1,350 @@
+import { DataSource } from '@/models';
+import { ObservationRecord } from '@/utils/plotting/observation-record';
+export type EnumDictionary<T extends string | symbol | number, U> = {
+    [K in T]: U;
+};
+export declare enum TimeUnit {
+    SECOND = "s",
+    MINUTE = "m",
+    HOUR = "h",
+    DAY = "D",
+    WEEK = "W",
+    MONTH = "M",
+    YEAR = "Y"
+}
+export declare enum EnumEditOperations {
+    ADD_POINTS = "ADD_POINTS",
+    CHANGE_VALUES = "CHANGE_VALUES",
+    DELETE_POINTS = "DELETE_POINTS",
+    DRIFT_CORRECTION = "DRIFT_CORRECTION",
+    INTERPOLATE = "INTERPOLATE",
+    SHIFT_DATETIMES = "SHIFT_DATETIMES",
+    FILL_GAPS = "FILL_GAPS"
+}
+export declare enum EnumFilterOperations {
+    FIND_GAPS = "FIND_GAPS",
+    PERSISTENCE = "PERSISTENCE",
+    CHANGE = "CHANGE",
+    RATE_OF_CHANGE = "RATE_OF_CHANGE",
+    VALUE_THRESHOLD = "VALUE_THRESHOLD"
+}
+export declare enum FilterOperation {
+    LT = "Less than",
+    LTE = "Less than or equal to",
+    GT = "Greater than",
+    GTE = "Greater than or equal to",
+    E = "Equal",
+    START = "Start datetime",
+    END = "End datetime"
+}
+export declare const FilterOperationFn: EnumDictionary<FilterOperation, (value: number, toCompare: number) => boolean>;
+export declare enum Operator {
+    ADD = "ADD",
+    SUB = "SUB",
+    MULT = "MULT",
+    DIV = "DIV",
+    ASSIGN = "ASSIGN"
+}
+export declare enum LogicalOperation {
+    LT = "Less than",
+    LTE = "Less than or equal to",
+    GT = "Greater than",
+    GTE = "Greater than or equal to",
+    E = "Equal"
+}
+export declare const LogicalComparator: EnumDictionary<LogicalOperation, (value: number, toCompare: number) => boolean>;
+export type HistoryItem = {
+    method: EnumEditOperations;
+    icon: string;
+    isLoading: boolean;
+    args?: any[];
+    duration?: number;
+    status?: 'success' | 'failed';
+};
+export type DataPoint = {
+    date: Date;
+    value: number;
+};
+export type DataArray = [string, number][];
+export interface GraphSeries {
+    id: string;
+    name: string;
+    data: ObservationRecord;
+    yAxisLabel: string;
+    seriesOption: any;
+}
+export type TimeSpacingUnit = 'seconds' | 'minutes' | 'hours' | 'days';
+export interface Tag {
+    key: string;
+    value: string;
+}
+export type Frequency = 'daily' | 'weekly' | 'monthly' | null;
+export declare class HydroShareArchive {
+    id: string;
+    thingId: string;
+    link: string;
+    frequency: Frequency;
+    path: string;
+    datastreamIds: string[];
+    publicResource: boolean;
+    constructor();
+}
+export declare class PostHydroShareArchive extends HydroShareArchive {
+    resourceTitle?: string;
+    resourceAbstract?: string;
+    resourceKeywords?: string[];
+    constructor();
+}
+export declare class Location {
+    latitude?: number | '';
+    longitude?: number | '';
+    elevation_m?: number | '';
+    elevationDatum: string;
+    state: string;
+    county: string;
+    country: string;
+    constructor();
+}
+export declare class Thing {
+    id: string;
+    workspaceId: string;
+    name: string;
+    location: Location;
+    tags: Tag[];
+    hydroShareArchive?: HydroShareArchive | null;
+    siteType: string;
+    samplingFeatureCode: string;
+    isPrivate: boolean;
+    description: string;
+    samplingFeatureType: string;
+    dataDisclaimer: string;
+    constructor();
+}
+export interface ThingWithColor extends Thing {
+    color?: {
+        borderColor: string;
+        background: string;
+        glyphColor: string;
+    };
+    tagValue?: string;
+}
+export declare class Datastream {
+    id: string;
+    workspaceId: string;
+    name: string;
+    description: string;
+    thingId: string;
+    observationType: string;
+    resultType?: string;
+    status?: string;
+    sampledMedium: string;
+    noDataValue: number;
+    aggregationStatistic: string;
+    unitId: string;
+    observedPropertyId: string;
+    sensorId: string;
+    processingLevelId: string;
+    isPrivate: boolean;
+    isVisible: boolean;
+    phenomenonBeginTime?: string | null;
+    phenomenonEndTime?: string | null;
+    intendedTimeSpacing?: number;
+    intendedTimeSpacingUnit?: TimeSpacingUnit | null;
+    timeAggregationInterval: number | null;
+    timeAggregationIntervalUnit: TimeSpacingUnit;
+    dataSourceId?: string | null;
+    valueCount: number;
+    constructor(thingId?: string);
+}
+export interface DatastreamExtended {
+    id: string;
+    name: string;
+    description: string;
+    observationType: string;
+    resultType?: string;
+    status?: string;
+    sampledMedium: string;
+    noDataValue: number;
+    aggregationStatistic: string;
+    isPrivate: boolean;
+    isVisible: boolean;
+    phenomenonBeginTime?: string | null;
+    phenomenonEndTime?: string | null;
+    intendedTimeSpacing?: number;
+    intendedTimeSpacingUnit?: TimeSpacingUnit | null;
+    timeAggregationInterval: number | null;
+    timeAggregationIntervalUnit: TimeSpacingUnit;
+    dataSourceId?: string | null;
+    valueCount: number;
+    thing: Thing;
+    workspace: Workspace;
+    unit: Unit;
+    observedProperty: ObservedProperty;
+    sensor: Sensor;
+    processingLevel: ProcessingLevel;
+    dataSource: DataSource;
+}
+export declare class Unit {
+    id: string;
+    workspaceId: string;
+    name: string;
+    symbol: string;
+    definition: string;
+    type: string;
+    constructor();
+}
+export declare class Sensor {
+    id: string;
+    workspaceId: string;
+    name: string;
+    description: string;
+    manufacturer: string;
+    model: string;
+    methodType: string;
+    methodCode: string;
+    methodLink: string;
+    encodingType: string;
+    modelLink: string;
+    constructor();
+}
+export declare class ObservedProperty {
+    id: string;
+    workspaceId: string;
+    name: string;
+    definition: string;
+    description: string;
+    type: string;
+    code: string;
+    constructor();
+}
+export declare class ProcessingLevel {
+    id: string;
+    workspaceId: string;
+    code: string;
+    definition: string;
+    explanation: string;
+    constructor();
+}
+export declare class ResultQualifier {
+    id: string;
+    workspaceId: string;
+    code: string;
+    description: string;
+    constructor();
+}
+export declare class Organization {
+    name?: string;
+    code?: string;
+    type?: string;
+    description?: string;
+    link?: string;
+    constructor();
+}
+export declare class User {
+    id: string;
+    email: string;
+    password: string;
+    firstName: string;
+    middleName: string;
+    lastName: string;
+    phone: string;
+    address: string;
+    organization?: Organization | null;
+    type: string;
+    link: string;
+    accountType: 'admin' | 'standard' | 'limited';
+    hydroShareConnected: boolean;
+    constructor();
+}
+export interface Photo {
+    name: string;
+    link: string;
+}
+export declare class OAuthProvider {
+    id: string;
+    name: string;
+    iconLink: string;
+    signupEnabled: boolean;
+    connectEnabled: boolean;
+    constructor();
+}
+export declare enum PermissionAction {
+    Global = "*",
+    View = "view",
+    Create = "create",
+    Edit = "edit",
+    Delete = "delete"
+}
+export declare enum PermissionResource {
+    Global = "*",
+    Workspace = "Workspace",
+    Collaborator = "Collaborator",
+    Thing = "Thing",
+    Datastream = "Datastream",
+    Sensor = "Sensor",
+    Unit = "Unit",
+    ObservedProperty = "ObservedProperty",
+    ProcessingLevel = "ProcessingLevel",
+    Observation = "Observation"
+}
+export interface Permission {
+    action: PermissionAction;
+    resource: PermissionResource;
+}
+export interface CollaboratorRole {
+    name: string;
+    description: string;
+    id: string;
+    workspaceId: string;
+    isApikeyRole: boolean;
+    isUserRole: boolean;
+    permissions: Permission[];
+}
+export declare class ApiKey {
+    id: string;
+    key: string;
+    name: string;
+    description: string;
+    isActive: boolean;
+    expiresAt: string;
+    createdAt: string;
+    lastUsed: string;
+    workspaceId: string;
+    role: CollaboratorRole | null;
+    constructor(init?: Partial<ApiKey>);
+}
+export interface WorkspaceData {
+    id: string;
+    name: string;
+    isPrivate: boolean;
+    owner: User;
+    collaboratorRole: CollaboratorRole;
+    pendingTransferTo?: User | null;
+}
+export declare class Workspace {
+    id: string;
+    name: string;
+    isPrivate: boolean;
+    owner: UserInfo | null;
+    collaboratorRole: CollaboratorRole | null;
+    pendingTransferTo?: UserInfo | null;
+    constructor();
+}
+export interface UserInfo {
+    name: string;
+    email: string;
+    phone: string;
+    address: string;
+    link: string;
+    type: string;
+    organizationName: string;
+}
+export declare class Collaborator {
+    user: UserInfo;
+    role: CollaboratorRole;
+    constructor();
+}
+export interface ApiError {
+    status: number;
+    message?: string;
+}

package/dist/utils/__tests__/ellapsed-time.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/__tests__/observations.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/ellapsed-time.d.ts

@@ -0,0 +1,4 @@
+export declare const measureEllapsedTime: (fn: () => any, message?: string) => Promise<{
+    response: any;
+    duration: number;
+}>;

package/dist/utils/format.d.ts

@@ -0,0 +1,5 @@
+import { EnumDictionary, TimeUnit } from '@/types';
+export declare const timeUnitMultipliers: EnumDictionary<TimeUnit, number>;
+export declare const formatDate: (date: Date) => string;
+export declare const formatDuration: (duration: number) => string;
+export declare const shiftDatetime: (datetime: number, amount: number, unit: TimeUnit) => number;

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './format';
+export * from './ellapsed-time';
+export * from './notifications';
+export * from './observations';
+export * from './plotting/observation-record';

package/dist/utils/observations.d.ts

@@ -0,0 +1,5 @@
+export declare function subtractHours(timestamp: string, hours: number): string;
+/** Returns the index of the first value that is greater or equal to the target value */
+export declare const findFirstGreaterOrEqual: (array: number[] | Float64Array<SharedArrayBuffer>, target: number) => number;
+/** Returns the index of the last value that is lesser or equal to the target value */
+export declare const findLastLessOrEqual: (array: number[] | Float64Array<SharedArrayBuffer>, target: number) => number;

package/dist/utils/plotting/__tests__/observation-record.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/plotting/{observationRecord.d.ts → observation-record.d.ts}

@@ -1,26 +1,4 @@
-import { EnumDictionary, EnumEditOperations, EnumFilterOperations, HistoryItem } from '../../types';
-export declare function subtractHours(timestamp: string, hours: number): string;
-/** Returns the index of the first value that is greater or equal to the target value */
-export declare const findFirstGreaterOrEqual: (array: number[] | Float64Array<SharedArrayBuffer>, target: number) => number;
-/** Returns the index of the last value that is lesser or equal to the target value */
-export declare const findLastLessOrEqual: (array: number[] | Float64Array<SharedArrayBuffer>, target: number) => number;
-export declare const measureEllapsedTime: (fn: () => any, message?: string) => Promise<{
-    response: any;
-    duration: number;
-}>;
-export declare enum TimeUnit {
-    SECOND = "s",
-    MINUTE = "m",
-    HOUR = "h",
-    DAY = "D",
-    WEEK = "W",
-    MONTH = "M",
-    YEAR = "Y"
-}
-export declare const timeUnitMultipliers: EnumDictionary<TimeUnit, number>;
-export declare const formatDate: (date: Date) => string;
-export declare const formatDuration: (duration: number) => string;
-export declare const shiftDatetime: (datetime: number, amount: number, unit: TimeUnit) => number;
+import { EnumEditOperations, EnumFilterOperations, HistoryItem } from '../../types';
 /**
  * This number should approximate the number of observations that a dataset could increase by during a session.
  * The lower this number, the less memory the entire app uses.
@@ -152,6 +130,13 @@ export declare class ObservationRecord {
      * @returns
      */
     private _rateOfChange;
+    /**
+   *
+   * @param comparator
+   * @param value
+   * @returns
+   */
+    private _change;
     /**
      * Find gaps in the data
      * @param value The time value

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uwrl/qc-utils",
-  "version": "0.0.14",
+  "version": "0.0.17",
   "description": "Quality Control Utilities",
   "homepage": "https://github.com/hydroserver2/qc-utils#readme",
   "bugs": {