@syncmatters/script-api 1.0.0

package/lib/utilities/file-provider/file-provider-buffer.d.ts

@@ -0,0 +1,11 @@
+import { FileProvider } from "./file-provider.js";
+export declare class FileProviderBuffer implements FileProvider {
+    constructor(source: Buffer);
+    length(): Promise<number>;
+    stream(encoding?: "utf8" | "utf16le" | "ucs2" | "latin1"): Promise<NodeJS.ReadableStream>;
+    formDataValue(encoding?: "utf8" | "utf16le" | "ucs2" | "latin1"): Promise<unknown>;
+    blob(fileName?: string): Promise<Blob>;
+    save(path?: string): Promise<string>;
+    close(): Promise<void>;
+    toJSON(): string;
+}

package/lib/utilities/file-provider/file-provider-disk.d.ts

@@ -0,0 +1,12 @@
+import { FileProvider } from "./file-provider.js";
+export declare class FileProviderDisk implements FileProvider {
+    constructor(path: string, deleteOnClose?: boolean);
+    length(): Promise<number>;
+    stream(encoding?: "utf8" | "utf16le" | "ucs2" | "latin1"): Promise<NodeJS.ReadableStream>;
+    private _initStreamSync;
+    formDataValue(encoding?: "utf8" | "utf16le" | "ucs2" | "latin1"): Promise<unknown>;
+    blob(fileName?: string): Promise<Blob>;
+    save(path?: string): Promise<string>;
+    close(): Promise<void>;
+    toJSON(): string;
+}

package/lib/utilities/file-provider/file-provider-string.d.ts

@@ -0,0 +1,11 @@
+import { FileProvider } from "./file-provider.js";
+export declare class FileProviderString implements FileProvider {
+    constructor(source: string);
+    length(): Promise<number>;
+    stream(encoding?: "utf8" | "utf16le" | "ucs2" | "latin1"): Promise<NodeJS.ReadableStream>;
+    formDataValue(encoding?: "utf8" | "utf16le" | "ucs2" | "latin1"): Promise<unknown>;
+    blob(fileName?: string): Promise<Blob>;
+    save(path?: string): Promise<string>;
+    close(): Promise<void>;
+    toJSON(): string;
+}

package/lib/utilities/file-provider/file-provider.d.ts

@@ -0,0 +1,21 @@
+export interface FileProvider {
+    length(): Promise<number>;
+    stream(encoding?: "utf8" | "utf16le" | "ucs2" | "latin1"): Promise<NodeJS.ReadableStream>;
+    close(): Promise<void>;
+    save(path?: string): Promise<string>;
+    formDataValue(encoding?: "utf8" | "utf16le" | "ucs2" | "latin1"): Promise<unknown>;
+    blob(fileName?: string): Promise<Blob>;
+    toJSON(): string;
+}
+export interface FileProviderOptions {
+    file?: {
+        path: string;
+        deleteOnClose?: boolean;
+    };
+    string?: string;
+    buffer?: Buffer;
+}
+export declare function fileProvider(options: FileProviderOptions): FileProvider;
+export declare namespace fileProvider {
+    var isFileProvider: (value: unknown) => value is FileProvider;
+}

package/lib/utilities/file-utils/file-utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Creates a temporary directory; caller should delete the directory once complete.
+ */
+export declare function tempDir(): Promise<string>;
+/**
+ * Creates a unique temporary file name; caller should delete the file once complete.
+ */
+export declare function tempFile(): Promise<string>;

package/lib/utilities/html-utils/html-utils.d.ts

@@ -0,0 +1 @@
+export declare function htmlToText(html: string): string;

package/lib/utilities/http-client/fetch-http-client.d.ts

@@ -0,0 +1,7 @@
+import { HttpClientOptions, HttpRequest, HttpClient } from "./types.js";
+/** Implementation of the HttpClient interface that uses the fetch API */
+export declare class FetchHttpClient implements HttpClient {
+    #private;
+    constructor(options?: HttpClientOptions);
+    execute(obj: HttpRequest): Promise<any>;
+}

package/lib/utilities/http-client/fetch-http-error.d.ts

@@ -0,0 +1,14 @@
+import { type HttpError as HttpErrorType } from "./types.js";
+export declare class HttpError extends Error implements HttpErrorType {
+    code: string;
+    statusCode?: number;
+    url?: string;
+    cause?: Error;
+    responseHeaders?: {
+        [key: string]: string;
+    };
+    responseBodyString?: string;
+    responseBodyBuffer?: Buffer;
+    responseBodyJson?: unknown;
+    constructor(err: Error | string, statusCode: number | undefined);
+}

package/lib/utilities/http-client/types.d.ts

@@ -0,0 +1,62 @@
+import type { Buffer } from "node:buffer";
+import { RateLimiter } from "../rate-limiter/rate-limiter.js";
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+/**
+ * HttpError thrown by the HttpClient on non-2xx responses.
+ */
+export interface HttpError extends Error {
+    /** the error name */
+    name: string;
+    /** the shaped error code, if available (e.g. HTTP errors become HTTP500, etc.) */
+    code: string;
+    /** the HTTP status number, if available */
+    statusCode?: number;
+    /** the original URL that the request was made to */
+    url?: string;
+    /** the original error that threw */
+    cause?: Error;
+    /** lowercase response headers map */
+    responseHeaders?: {
+        [key: string]: string;
+    };
+    /** the response body as a string, if available */
+    responseBodyString?: string;
+    /** the response body as a buffer, if available */
+    responseBodyBuffer?: Buffer;
+    /** the response body as a JSON object, if available */
+    responseBodyJson?: unknown;
+}
+/** HttpRequest defines the POST/GET/... request to be processed by an HttpClient. */
+export interface HttpRequest {
+    method: HttpMethod;
+    url: string;
+    headers?: any;
+    body?: any;
+    limiterCost?: number;
+    fullResponse?: boolean;
+    fileResponse?: boolean;
+}
+/** HttpCanRetry is an optional interface allowing a connector to assess whether a retry is allowed */
+export interface HttpCanRetry {
+    (err: HttpError, method: HttpMethod, url: string, httpCode: number, responseHeaders: {
+        [key: string]: string;
+    } | undefined): boolean | number;
+}
+/** HttpClientOptions allow customization of the HttpClient defaults. */
+export interface HttpClientOptions {
+    defaultHeaders?: {
+        [key: string]: string;
+    };
+    timeoutMs?: number;
+    limiter?: RateLimiter;
+    maxRetry?: number;
+    retryBackoffMs?: number;
+    ca?: Buffer;
+    errMessageFormat?: "default" | "concise";
+    canRetry?: HttpCanRetry;
+    onError?: (err: HttpError, method: HttpMethod, url: string, httpCode: number, reqJson?: unknown) => void;
+    onSuccess?: (method: string, url: string, httpCode: number, reqJson?: unknown) => void;
+}
+export interface HttpClient {
+    execute: (request: HttpRequest) => Promise<any>;
+}

package/lib/utilities/json-utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./lossless-numbers.js";
+export * from "./json-values-types.js";
+export * from "./json-values-reader.js";
+export * from "./json-values-writer.js";
+export * from "./json-changed-checker.js";
+export * from "./paths.js";

package/lib/utilities/json-utils/json-changed-checker.d.ts

@@ -0,0 +1,15 @@
+import API from "../../../index.js";
+export type JsonChangedCheckerFormat = "csv";
+export interface JsonChangedCheckerOptions {
+    data: API.FileProvider;
+    format: JsonChangedCheckerFormat;
+}
+export declare function JsonChangedChecker(options: JsonChangedCheckerOptions): Promise<Checker>;
+declare class Checker {
+    #private;
+    constructor(options: JsonChangedCheckerOptions);
+    _init(): Promise<void>;
+    hasChanged(id: string, json: unknown): Promise<boolean>;
+    data(): Promise<API.FileProvider | undefined>;
+}
+export {};

package/lib/utilities/json-utils/json-hash.d.ts

@@ -0,0 +1,4 @@
+export declare function JsonHash(options: {
+    json: unknown;
+    csvMode: boolean;
+}): string;

package/lib/utilities/json-utils/json-values-reader.d.ts

@@ -0,0 +1,13 @@
+import { JsonValuePath } from "./json-values-types.js";
+/** Efficiently read a set of property values from a JSON object */
+export declare class JsonValuesReader {
+    #private;
+    constructor(options: {
+        paths: Array<JsonValuePath>;
+        dontThrowOnInvalidParent?: boolean;
+    });
+    /** Perform the read
+     * @param json - the JSON object to read from
+     */
+    execute(json: unknown): Array<unknown>;
+}

package/lib/utilities/json-utils/json-values-types.d.ts

@@ -0,0 +1,41 @@
+/** JsonValuePath is the specification a path when traversing a JSON blob to get/set a value */
+export type JsonValuePath = Array<JsonValuePathPart>;
+/**
+ * JsonValuePathPart is the specification of one path part when traversing a JSON blob to get/set a value; a full
+ * path to a vlaue would consist of an array pf these path parts
+ */
+export interface JsonValuePathPart {
+    /** name of the property on the parent object, or "[0-n]" if the property is an array */
+    path: string;
+    /** in the case of an array this specifies how to select the correct value from the array */
+    array?: {
+        /** select all values from the array */
+        selectAll?: boolean;
+        /** select value at a specific index */
+        index?: number;
+        /** sort the array before selecting the value at an index */
+        sort?: {
+            /** path to the property to be used when sorting the array */
+            path?: string[];
+            /** sort descending (default is ascending) */
+            desc?: boolean;
+        };
+        /** filters to use when identifying array element to get/set */
+        filters?: Array<{
+            /** reference to a property on the selected value to filter by */
+            path?: string[];
+            /** operator to use when checking if the value at the path meets filter */
+            operator?: "eq" | "geq" | "leq" | "empty" | "notempty" | "anyof";
+            /** string value to use in comparison of the operator is singular */
+            valueString?: string;
+            /** string values to use in comparison of the operator is multiple */
+            valuesString?: string[];
+            /** numeric value to use in comparison of the operator is singular */
+            valueNum?: number;
+            /** numeric values to use in comparison of the operator is multiple */
+            valuesNum?: number[];
+            /** boolean value to use in comparison of the operator is singular */
+            valueBool?: boolean;
+        }>;
+    };
+}

package/lib/utilities/json-utils/json-values-writer.d.ts

@@ -0,0 +1,28 @@
+import { JsonValuePath } from "./json-values-types.js";
+export interface WriteBehaviour {
+    executeOn?: "add" | "update";
+    writeNulls?: boolean;
+    writeEmptyStrings?: boolean;
+    dontOverwrite?: boolean;
+}
+/**
+ * Efficiently write a set of values into a JSON object. Can handle nested objects, and at most a single array
+ * in the field path or at the leaf level.
+ *
+ * Note: array selectors / specifiers such as index: 0 and selectAll: true are not supported.
+ */
+export declare class JsonValuesWriter {
+    #private;
+    constructor(options: {
+        fields: Array<{
+            path: JsonValuePath;
+            behaviour?: WriteBehaviour;
+        }>;
+    });
+    /** Perform the write
+     * @param output - the JSON object to write into
+     * @param newValues - the new values to be written to each field in the JSON output
+     * @param oldValues - the current values of each field to evaluate behaviors
+     */
+    execute(output: unknown, newValues: Array<unknown>, oldValues?: Array<unknown>, isUpdate?: boolean): void;
+}

package/lib/utilities/json-utils/lossless-numbers.d.ts

@@ -0,0 +1,6 @@
+import { LosslessNumber } from "lossless-json";
+export declare function stringToLosslessNumber(source?: string): LosslessNumber | null | undefined;
+export declare function stringsToLosslessNumbers(source: unknown | undefined, paths: Array<Array<string>>): unknown;
+export declare function stringsFromLosslessNumbers(source: unknown | undefined, paths: Array<string[]>): void;
+export declare function parseWithLosslessNumbers(source: string): unknown;
+export declare function stringifyWithLosslessNumbers(source: unknown): string | undefined;

package/lib/utilities/json-utils/paths.d.ts

@@ -0,0 +1,8 @@
+import { JsonValuePath } from "./json-values-types.js";
+import { ObjectField } from "../../connection.js";
+/** Convert hierarchical connection object fields to period-separated field paths e.g. addresses.[0-n].street */
+export declare function fieldsToFieldPaths(fields?: ObjectField[]): Map<string, ObjectField>;
+/** Convert a period-separated field path to the the format used to get/set fields using JSON utils */
+export declare function fieldPathToJsonValuePath(fieldPath: string, arrayRule?: "throw" | "first" | "all"): JsonValuePath;
+/** Convert a list of period-separated field paths to the the format used to get/set fields using JSON utils */
+export declare function fieldsPathToJsonValuePaths(fieldPaths: string[], arrayRule?: "throw" | "first" | "all"): JsonValuePath[];

package/lib/utilities/kv-store/better-sqlite3/kv-collection-better-sqlite3.d.ts

@@ -0,0 +1,18 @@
+import { KvIteratorSqlite3 } from "./kv-iterator-better-sqlite3.js";
+import { KvCollection, KvStore } from "../types.js";
+export declare class KvCollectionBetterSqlite3<T> implements KvCollection<T> {
+    #private;
+    name: string;
+    constructor(collInfo: {
+        store: KvStore;
+        name: string;
+        tableName: string;
+        fname: string;
+    });
+    close(): Promise<void>;
+    put(key: string | number, v: T): Promise<T | undefined>;
+    get(key: string | number): Promise<T | undefined>;
+    del(key: string | number): Promise<void>;
+    iterator(): KvIteratorSqlite3<T>;
+    init(): Promise<void>;
+}

package/lib/utilities/kv-store/better-sqlite3/kv-iterator-better-sqlite3.d.ts

@@ -0,0 +1,26 @@
+import { KvIterator } from "../types.js";
+import BetterSqlite3 from "better-sqlite3";
+type NativeDb = InstanceType<typeof BetterSqlite3>;
+/** Narrow surface the iterator needs from its owning collection. */
+export interface KvIteratorBacking {
+    getDb(): NativeDb | undefined;
+    getTableName(): string;
+    getRegisteredIterator(): {
+        close(): Promise<void>;
+    } | undefined;
+    registerIterator(iter: {
+        close(): Promise<void>;
+    }): void;
+    unregisterIterator(): void;
+}
+export declare class KvIteratorSqlite3<T> implements KvIterator<T> {
+    #private;
+    constructor(backing: KvIteratorBacking, checkInit: () => Promise<void>);
+    rows<U>(): AsyncIterableIterator<U>;
+    rowsWithKeys<U>(): AsyncIterableIterator<{
+        key: string | number;
+        data: U;
+    }>;
+    close(): Promise<void>;
+}
+export {};

package/lib/utilities/kv-store/better-sqlite3/kv-store-better-sqlite3.d.ts

@@ -0,0 +1,11 @@
+import { KvCollection, KvStore } from "../types.js";
+export interface KvStoreBetterSqlite3Args {
+    path: string;
+}
+export declare class KvStoreBetterSqlite3 implements KvStore {
+    #private;
+    constructor(options?: KvStoreBetterSqlite3Args);
+    open<T>(name: string): Promise<KvCollection<T>>;
+    close(name: string): Promise<void>;
+    exit(): Promise<void>;
+}

package/lib/utilities/kv-store/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export { KvStoreSqlite3 } from "./sqlite3/kv-store-sqlite3.js";
+export { KvStoreShadow } from "./shadow/kv-store-shadow.js";
+export { KvStoreBetterSqlite3 } from "./better-sqlite3/kv-store-better-sqlite3.js";

package/lib/utilities/kv-store/kv-store-benchmark-helpers.d.ts

@@ -0,0 +1,14 @@
+import type { KvStore } from "./types.js";
+export interface KvStoreBenchmarkResult {
+    implementation: string;
+    rowCount: number;
+    putsMs: number;
+    getsMs: number;
+    iterateMs: number;
+}
+/**
+ * Runs comparable put / get / full-scan iteration timings for a KvStore implementation.
+ * Uses a fresh temp directory per run.
+ */
+export declare function runKvStoreBenchmark(implementation: string, createStore: (storeDir: string) => KvStore, rowCount: number): Promise<KvStoreBenchmarkResult>;
+export declare function logKvStoreBenchmarkResult(r: KvStoreBenchmarkResult): void;

package/lib/utilities/kv-store/shadow/kv-store-shadow.d.ts

@@ -0,0 +1,29 @@
+import type { KvCollection, KvIterator, KvStore } from "../types.js";
+/** Deep equality for JSON-like values stored in KV collections. */
+export declare function kvShadowValuesEqual(a: unknown, b: unknown): boolean;
+export declare class KvStoreShadow implements KvStore {
+    #private;
+    constructor(primary: KvStore, secondary: KvStore);
+    open<T>(name: string): Promise<KvCollection<T>>;
+    close(name: string): Promise<void>;
+    exit(): Promise<void>;
+}
+export declare class KvCollectionShadow<T> implements KvCollection<T> {
+    #private;
+    constructor(primary: KvCollection<T>, secondary: KvCollection<T>);
+    close(): Promise<void>;
+    put(key: string | number, data: T): Promise<T | undefined>;
+    get(key: string | number): Promise<T | undefined>;
+    del(key: string | number): Promise<void>;
+    iterator(): KvIterator<T>;
+}
+export declare class KvIteratorShadow<T> implements KvIterator<T> {
+    #private;
+    constructor(primary: KvIterator<T>, secondary: KvIterator<T>);
+    rowsWithKeys(): AsyncIterableIterator<{
+        key: string | number;
+        data: T;
+    }>;
+    rows(): AsyncIterableIterator<T>;
+    close(): Promise<void>;
+}

package/lib/utilities/kv-store/sqlite3/database-sqlite3.d.ts

@@ -0,0 +1,16 @@
+export declare class DatabaseSqite3 {
+    static get OPEN_READONLY(): number;
+    static get OPEN_READWRITE(): number;
+    static get OPEN_CREATE(): number;
+    static open(filename: string, mode?: number): Promise<any>;
+    private db;
+    open(filename: string, mode?: number): Promise<any>;
+    close(fn: any): Promise<any>;
+    run(...args: any[]): Promise<any>;
+    get(...args: any[]): Promise<any>;
+    all(...args: any[]): Promise<any>;
+    each(...args: any[]): Promise<any>;
+    exec(sql: string): Promise<any>;
+    transaction(fn: any): Promise<any>;
+    prepare(...args: any[]): Promise<any>;
+}

package/lib/utilities/kv-store/sqlite3/kv-collection-sqlite3.d.ts

@@ -0,0 +1,18 @@
+import { KvIteratorSqlite3 } from "./kv-iterator-sqlite3.js";
+import { KvCollection } from "../types.js";
+export declare class KvCollectionSqlite3<T> implements KvCollection<T> {
+    name: string;
+    private isClosed;
+    private isInit;
+    private stmtIns;
+    private stmtUpd;
+    private stmtSel;
+    private stmtDel;
+    constructor(collInfo: any);
+    close(): Promise<void>;
+    put<T>(key: string | number, v: T): Promise<T | undefined>;
+    get<T>(key: string | number): Promise<T>;
+    del(key: string | number): Promise<void>;
+    iterator(): KvIteratorSqlite3<T>;
+    init(): Promise<void>;
+}

package/lib/utilities/kv-store/sqlite3/kv-iterator-sqlite3.d.ts

@@ -0,0 +1,21 @@
+import { KvIterator } from "../types.js";
+export declare class KvIteratorSqlite3<T> implements KvIterator<T> {
+    private idx;
+    private current;
+    private ids;
+    private stmt;
+    private isClosed;
+    private _checkInit;
+    constructor(collInfo: any, checkInit: () => Promise<void>);
+    rows<T>(): AsyncIterableIterator<T>;
+    rowsWithKeys<T>(): AsyncIterableIterator<{
+        key: string | number;
+        data: T;
+    }>;
+    close(): Promise<void>;
+    private _init;
+    private _goToFirst;
+    private _goToNext;
+    private _getCurrentObject;
+    private _gotoIdx;
+}

package/lib/utilities/kv-store/sqlite3/kv-store-sqlite3.d.ts

@@ -0,0 +1,11 @@
+import { KvStore } from "../types.js";
+import { KvCollectionSqlite3 } from "./kv-collection-sqlite3.js";
+export interface KvStoreSqlite3Args {
+    path: string;
+}
+export declare class KvStoreSqlite3 implements KvStore {
+    constructor(options?: KvStoreSqlite3Args);
+    open<T>(name: string): Promise<KvCollectionSqlite3<unknown>>;
+    close(name: string): Promise<void>;
+    exit(): Promise<void>;
+}

package/lib/utilities/kv-store/sqlite3/statement-sqlite3.d.ts

@@ -0,0 +1,13 @@
+export declare class StatementSqlite3 {
+    lastID: any;
+    changes: any;
+    private statement;
+    constructor(statement: any);
+    bind(...args: any[]): Promise<unknown>;
+    reset(): Promise<unknown>;
+    finalize(): Promise<void>;
+    run(...args: any[]): Promise<unknown>;
+    get(...args: any[]): Promise<unknown>;
+    all(...args: any[]): Promise<unknown>;
+    each(...args: any[]): Promise<unknown>;
+}

package/lib/utilities/kv-store/types.d.ts

@@ -0,0 +1,20 @@
+export interface KvStore {
+    open<T>(name: string): Promise<KvCollection<T>>;
+    close(name: string): Promise<void>;
+    exit(): Promise<void>;
+}
+export interface KvCollection<T> {
+    close(): Promise<void>;
+    put(key: string | number, data: T): Promise<T | undefined>;
+    get(key: string | number): Promise<T | undefined>;
+    del(key: string | number): Promise<void>;
+    iterator(): KvIterator<T>;
+}
+export interface KvIterator<T> {
+    rows(): AsyncIterableIterator<T>;
+    rowsWithKeys(): AsyncIterableIterator<{
+        key: string | number;
+        data: T;
+    }>;
+    close(): Promise<void>;
+}

package/lib/utilities/name-parser/name-parser.d.ts

@@ -0,0 +1,6 @@
+export declare function nameParser(name: string): {
+    title: string;
+    first: string;
+    middle: string;
+    last: string;
+};

package/lib/utilities/rate-limiter/rate-limiter-concurrent.d.ts

@@ -0,0 +1,24 @@
+import { RateLimiter } from "./rate-limiter.js";
+interface ExecutorSpec {
+    executor: () => Promise<any>;
+    resolve: (value: any) => void;
+    reject: (reason: any) => void;
+    offset: number;
+    cost: number;
+}
+/**
+ * RateLimiterConcurrent is a concurrent executions rate limiter.
+ */
+export declare class RateLimiterConcurrent implements RateLimiter {
+    #private;
+    constructor(maxConcurrent: number);
+    /** @deprecated */
+    take(cost?: number): Promise<void>;
+    execute<T>(options: {
+        cost?: number;
+        exec: () => Promise<T>;
+    }): Promise<T>;
+    _processPendingGenerators(): void;
+    _handleGenerator(spec: ExecutorSpec): Promise<void>;
+}
+export {};

package/lib/utilities/rate-limiter/rate-limiter-rolling.d.ts

@@ -0,0 +1,18 @@
+import { RateLimiter } from "./rate-limiter.js";
+/**
+ * RateLimiterRolling is a rolling time window rate limiter. As the time of writing the rate limiters avaiable on npm
+ * did not did limit accurately, menaning that the remote APIs (like HubSpots) would periodically respond with HTTP 429
+ * errors.
+ */
+export declare class RateLimiterRolling implements RateLimiter {
+    #private;
+    constructor(count: number, ms: number);
+    take(cost?: number): Promise<void>;
+    execute<T>(options: {
+        cost?: number;
+        exec: () => Promise<T>;
+    }): Promise<T>;
+    availableCount(): number;
+    private _startTimeout;
+    private _drainQueue;
+}

package/lib/utilities/rate-limiter/rate-limiter.d.ts

@@ -0,0 +1,15 @@
+/** RateLimiter allows resources (e.g. API calls) to be throttled to a specific rate. */
+export interface RateLimiter {
+    /** @deprecated use execute() */
+    take(cost?: number): Promise<void>;
+    execute<T>(options: {
+        cost?: number;
+        exec: () => Promise<T>;
+    }): Promise<T>;
+}
+/** RateLimiterOptions is passed to the rate limiter constructor when creating a new limiter. */
+export interface RateLimiterOptions {
+    type: "rolling" | "concurrent";
+    count?: number;
+    ms?: number;
+}

package/lib/utilities/type-utils/type-utils.d.ts

@@ -0,0 +1,11 @@
+export declare function isNullOrUndefined(value: any): boolean;
+export declare function isNull(value: any): boolean;
+export declare function isUndefined(value: any): boolean;
+export declare function isString(value: any): value is string | String;
+export declare function isNumber(value: any): value is number | Number;
+export declare function isInteger(value: any): boolean;
+export declare function isBoolean(value: any): value is boolean | Boolean;
+export declare function isDate(value: any): value is Date;
+export declare function isArray(value: any): value is any[];
+export declare function isBuffer(value: any): value is Buffer<ArrayBufferLike>;
+export declare function isFunction(value: any): boolean;

package/lib/utilities/upsert-flags/upsert-flags.d.ts

@@ -0,0 +1,10 @@
+export interface UpsertFlags {
+    /**
+     * For upsert operations the caller will set a value if the caller knows whether the row already exists.
+     */
+    operation?: "add" | "update";
+}
+/** Stamp the upsert flags onto the row */
+export declare function set(flags: UpsertFlags, row?: unknown): void;
+/** Collect the upsert flags from the row */
+export declare function get(row: unknown): UpsertFlags | undefined;