@syncmatters/script-api 1.0.0

package/lib/connection.d.ts

@@ -0,0 +1,597 @@
+import API from "../index.js";
+import { CodedError } from "./coded-error.js";
+import { FileProvider } from "./utilities/file-provider/file-provider.js";
+import { SyncEndpoint, SyncSession } from "./sync.js";
+export interface Connection {
+    /** org unique connection id */
+    readonly id: string;
+    readonly cache: Cache;
+    readonly base?: any;
+    readonly identity?: string;
+    readonly version?: string;
+    readonly name: string;
+    meta: {
+        objects: {
+            [id: string]: () => Promise<ObjectMeta>;
+        };
+        events: {
+            [id: string]: () => Promise<EventTypeMeta>;
+        };
+    };
+    query: {
+        [id: string]: (options?: QueryOptions) => QueryIterator<Row>;
+    };
+    queryOne: {
+        [id: string]: (options?: QueryOneOptions) => Promise<Row | undefined>;
+    };
+    upsert?: {
+        [id: string]: (rows: any[]) => Promise<Row[]>;
+    };
+    upsertClean?: {
+        [id: string]: (options: UpsertCleanOptions) => Promise<UpsertCleanResponse>;
+    };
+    delete?: {
+        [id: string]: (rows: any[]) => Promise<void>;
+    };
+    /** Id's of all objects found on this connection. */
+    objectIds: string[];
+    /** Connect to the source, validating credentials etc ... */
+    test(): Promise<TestResult>;
+    /** Retrieves the latest meta data (identity, object, field definitions, event types) from the connector. */
+    metaRefresh?(): Promise<void>;
+    /**
+     * Creates/updates the meta data model of a connection. This method is only applicable to connectors with
+     * data models that are managed by platform or user logic rather than through interrogation of the source application.
+     * @param options hold the updated item specification
+     * @param options.objects holds the updated object specifications
+     * @param options.objectSettingsValues [optional] holds the updated object settings
+     */
+    metaUpsert?(options: {
+        objects?: ObjectMetaUpsert[];
+        objectSettingsValues?: ObjectSettingsValuesUpsert[];
+    }): Promise<void>;
+    /**
+     * Requests that cached meta data (and data) for the object/event types be deleted.
+     * <p>
+     * Note: This function does not delete data/object definitions from from the underlying connector.
+     * If the meta data is acquired from a remote system then this meta data will be re-created on next
+     * metaRefresh() call. This function may be used when shaping connections that have hand (or script)
+     * managed data models.
+     * </p>
+     * @param options holds the unique identifiers of the items to be deleted from the cache (blank means clear all).
+     */
+    metaDelete?(options?: {
+        objectIds?: string[];
+    }): Promise<void>;
+    /**
+     * Requests the connection prepares for a session that will interact with sync(s)
+     * @param options session specification.
+     */
+    syncSession?(options: SyncSession): Promise<SyncEndpoint>;
+}
+export interface Cache {
+    count: {
+        [id: string]: () => Promise<number>;
+    };
+    query: {
+        [id: string]: (options?: CacheQueryOptions) => AsyncIterableIterator<CacheRow>;
+    };
+    queryOne: {
+        [id: string]: (options?: CacheQueryOneOptions) => Promise<CacheRow | undefined>;
+    };
+    upsert: {
+        [id: string]: (page: CacheUpsertPage) => Promise<void>;
+    };
+    delete: {
+        [id: string]: (options?: {
+            keys?: string[];
+        }) => Promise<void>;
+    };
+    refresh: {
+        [id: string]: (options?: {
+            forceFull?: boolean;
+        }) => Promise<void>;
+    };
+    lastRefresh: {
+        [id: string]: () => Promise<Date | undefined>;
+    };
+    bulkRefresh(options: CacheRefreshOptions): Promise<void>;
+    bulkCount(options: {
+        ids: string[];
+    }): Promise<{
+        [id: string]: number;
+    }>;
+}
+export interface CacheQueryOptions {
+    limit?: number;
+    rowFilter?: {
+        modifiedSince?: number;
+        index?: {
+            name: string;
+            values: string[];
+        };
+        keys?: string[];
+    };
+    propertyFilter?: {
+        metaOnly?: boolean;
+        noFile?: boolean;
+        properties?: {
+            name: string;
+            path: string[];
+        }[];
+        relationships?: string[];
+    };
+}
+export interface CacheQueryOneOptions {
+    rowFilter?: {
+        modifiedSince?: number;
+        index?: {
+            name: string;
+            values: string[];
+        };
+        key?: string;
+    };
+    propertyFilter?: {
+        metaOnly?: boolean;
+        noFile?: boolean;
+        properties?: {
+            name: string;
+            path: string[];
+        }[];
+        relationships?: string[];
+    };
+}
+export interface CacheUpsertPage {
+    rows?: CacheUpsertRow[];
+    state?: any;
+    lastRefresh?: Date;
+}
+export interface CacheRow {
+    meta: {
+        key: string;
+        hasFile?: boolean;
+        sequence?: number;
+        created: number;
+        modified: number;
+    };
+    data: object;
+    file?: FileProvider | null | undefined;
+}
+export interface CacheUpsertRow {
+    meta: {
+        key: string;
+    };
+    data?: any;
+    file?: FileProvider | null | undefined;
+}
+export interface CacheRefreshOptions {
+    objects: [
+        {
+            id: string;
+            forceFull?: boolean;
+        }
+    ];
+}
+/** TestResult is the reponse to a test() call */
+export interface TestResult {
+    success: boolean;
+    message?: string;
+    error?: CodedError;
+}
+/** QueryOptions holds filter options passed to a connection when querying data. */
+export interface QueryOptions {
+    /** limit the number of rows returned */
+    limit?: number;
+    /** include any file associated with each row? */
+    file?: boolean;
+    /** fields expected in the response */
+    fields?: Array<Array<API.JsonValuePathPart>>;
+    /** include fields needed to collect rows from selected relationships */
+    relationshipFields?: Array<string>;
+    /** retrieve a random sample of up to 'limit' records */
+    randomFilter?: boolean;
+    /** filter for rows by row id (key) */
+    idsFilter?: Array<string>;
+    /** filter for rows that relate to another object on this connection */
+    relatedFilter?: QueryRelatedFilter;
+    /** filter for rows that meet a specific matching rule */
+    matchFilter?: QueryMatchFilter;
+    /** collect records changed since a particular checkpoint */
+    checkpointFilter?: QueryCheckpointFilter;
+    /** row filter & property filter are system-specific and may support non-standard filters  */
+    rowFilter?: any;
+    propertyFilter?: any;
+}
+export type RowMatchRuleType = "id" /** match by source row id (key) */ | "name[ci]" /** match by destination row name (case senstive) */ | "email[ci]" /** match by destination row email (case insenstive) */ | "domain[ci]" /** match by destination domain (case insenstive) */ | "first_and_last_name[ci]" /** match by destination first and last name (case insenstive) */ | "field_value_equals[ci]"; /** match by value in user selected field (case insenstive) */
+export type RowMatchRuleOrder = "oldest" | "newest" | "alphabetical";
+/** source row data used by the destination connector when matching a source row to a destination row */
+export interface RowMatchData {
+    /** id of the source row we are trying to match to a destination row (used to correlate matches) */
+    srcRowId: string;
+    /** rule-specific values to test for when matching a source to to a related row */
+    match: {
+        /** destination system record id (key) to match */
+        id?: string;
+        /** name value to match */
+        name?: string;
+        /** email value to match */
+        email?: string;
+        /** domain value to match */
+        domain?: string;
+        /** first name value to match */
+        firstname?: string;
+        /** last name value to match */
+        lastname?: string;
+        /** custom value to match */
+        custom?: string | number;
+    };
+}
+/** unique ids (property names) used in the row match data passed to the destination when a match is saught */
+export type RowMatchValueUid = "id" /** value relates to source row id (key) */ | "name" /** value relates to destination row name */ | "email" /** value relates to destination row email */ | "domain" /** value relates to  destination domain */ | "firstname" /** value relates to destination first name */ | "lastname" /** value relates to destination last name */ | "custom"; /** value relates to user selected destination field */
+/** QueryOneOptions holds connector specific options passed to a query. */
+export interface QueryOneOptions {
+    /** include any file associated with each row? */
+    file?: boolean;
+    /** fields expected in the response */
+    fields?: Array<Array<API.JsonValuePathPart>>;
+    /** include fields needed to collect rows from selected relationships */
+    relationshipFields?: Array<string>;
+    /** filter for rows by row id (key) */
+    idsFilter?: Array<string>;
+    /** filter for rows that relate to another object on this connection */
+    relatedFilter?: QueryRelatedFilter;
+    /** filter for rows that meet a specific matching rule */
+    matchFilter?: QueryMatchFilter;
+    /** row filter & property filter are system-specific and may support non-standard filters  */
+    rowFilter?: any;
+    propertyFilter?: any;
+}
+/** Row is a record returned in response to a query. */
+export interface Row {
+    /** meta holds row metadata */
+    meta: {
+        /** unique identifier for the row on the object */
+        key: string;
+        /** indication that the row has been deleted from the object */
+        deleted?: boolean;
+        /** keys that have previously been assigned to this row (e.g. merged) */
+        previousKeys?: Array<string>;
+        /** URL users can click to view the row in the business system UI (if available) */
+        url?: string;
+    };
+    /** data is the row contents */
+    data?: any;
+    /** if filters requested files be included in the response, and the if row includes a file, the file will be here */
+    file?: FileProvider | null | undefined;
+    /** if filters requested rows filter by 'related', or 'matched' to source rows the relationship details will be here */
+    relationship?: {
+        relationshipId?: string;
+        srcObjectId?: string;
+        srcRowId: string;
+    };
+    /** if filters requested rows be returned from a 'checkpoint', the final row in the stream will return the next checkpoint here */
+    checkpoint?: string | undefined;
+}
+/** Iterator is returned in response to Query() operations  */
+export interface QueryIterator<T> extends AsyncIterableIterator<T> {
+    /** Checkpoint filters allow retrieval of the next checkpoint once all rows are collected */
+    nextCheckpoint?(): Promise<string | undefined>;
+}
+/** QueryRelatedFilter holds filters to apply when querying rows from this object that relate to rows from another object. */
+export interface QueryRelatedFilter {
+    /** id of the other object for which related rows from this object are saught */
+    otherObjectId: string;
+    /** unique id of the relationship defined on the other object that describes how other object rows relate to rows on this object */
+    otherRelationshipId: string;
+    /** rows from the other object for which related rows from this object are saught */
+    otherRows: Array<Row>;
+}
+/** QueryMatchFilter holds filters to apply when searching for matching rows. */
+export interface QueryMatchFilter {
+    /** rule to use to match */
+    rule: RowMatchRuleType;
+    /** in the case of multiple matches, how should the "best" match be selected */
+    selectOrder?: RowMatchRuleOrder;
+    /** if the rule references a field in the destination row the path to the destination field will be specified here (e.g. match value in a specific field) */
+    destFieldPath?: Array<API.JsonValuePathPart>;
+    /** data to match */
+    srcData: Array<RowMatchData>;
+    /**
+     * once the connector has identified candidates for the src rows, call this with possible candidates to select an un-mapped candidate.
+     * it will return the selected candidates, populating 'row.relationship' with details of the src row the match relates to.
+     */
+    canUse: (options: Array<{
+        srcRowId: string;
+        candidates: Array<Row>;
+    }>) => Promise<Array<Row>>;
+}
+/** QueryCheckpointFilter holds filters to apply when collecring rows changed since a prior checkpoint. */
+export interface QueryCheckpointFilter {
+    /** checkpoint last returned by this connector when this query was run */
+    value?: string;
+}
+/**
+ * EventTypeMeta is the definition of an event emitted by a connection.
+ */
+export interface EventTypeMeta {
+    id: string;
+    name?: string;
+    dataFields?: ObjectField[];
+}
+/**
+ * ObjectMeta defines the the features, user defined settings values & behavior of an object on a connection.
+ *
+ * Fields that must not be sent in `Connection.metaUpsert` payloads belong in {@link ObjectMetaUpsertExcludedKeys}
+ * so {@link ObjectMetaUpsert} stays aligned.
+ */
+export interface ObjectMeta {
+    id: string;
+    name?: string;
+    settingsMeta?: Record<string, ObjectSettingMeta>;
+    settingsValues?: Record<string, unknown>;
+    order?: string;
+    data?: any;
+    isCustom?: boolean;
+    queryFields?: ObjectField[];
+    queryFilter?: {
+        rowFilter?: ObjectRowFilter[];
+        propertyFilter?: ObjectField[];
+    };
+    queryFile?: boolean;
+    upsertFields?: ObjectField[];
+    deleteFields?: ObjectField[];
+    canQueryList?: boolean;
+    canQueryByCheckpoint?: boolean;
+    canQueryByIds?: boolean;
+    canQueryRandoms?: boolean;
+    canUpsertClean?: boolean;
+    canUpsertFieldOptions?: boolean;
+    canAddCustomRelationships?: boolean;
+    matchRules?: RowMatchRuleType[];
+    customIndexes?: ObjectIndex[];
+    systemIndexes?: ObjectIndex[];
+    /** relationships that may be used to find rows of this object that relate to other objects */
+    relationships?: ObjectRelationship[];
+}
+/** ObjectSettingMeta holds metadata describing a setting */
+export interface ObjectSettingMeta {
+    i18nKey?: string;
+    order?: string;
+    name?: string;
+    groupId?: string;
+    description?: string;
+    placeholder?: string;
+    secret?: boolean;
+    hidden?: boolean;
+    advanced?: boolean;
+    readonly?: boolean;
+    mandatory?: boolean;
+    displayIf?: string;
+    displayIfSetting?: string;
+    displayIfValues?: string[];
+    type?: string;
+    control?: string;
+    options?: ObjectSettingMetaOption[];
+    default?: unknown;
+    constraints?: ObjectFieldConstraints;
+}
+/** ObjectSettingMetaOption holds a metadata option value */
+export interface ObjectSettingMetaOption {
+    id: string;
+    name?: string;
+    order?: string;
+}
+export interface ObjectRowFilter {
+    /** unique identifier for the filter */
+    id: string;
+    /** data type of the json property value  */
+    type: "string" | "number" | "boolean" | "object" | "array";
+    /** display label for the field  */
+    name?: string;
+    /** for picklist fields, this holds the allowed options */
+    optionValues?: ObjectFieldOption[];
+    /** for object filters, these are the properties of the object */
+    objectFields?: ObjectRowFilter[];
+    /** for array filters, this is the type of each array element */
+    arrayType?: "string" | "number" | "boolean" | "object";
+    /** for array filters of type object, these are the properties of each array element */
+    arrayObjectFields?: ObjectRowFilter[];
+    /** 'data' may hold a small amount of info for connector-internal logic to reference */
+    data?: any;
+    /** identify where this filter can extend standard filters */
+    extends?: Array<{
+        type: "checkpoint" | "list" | "match";
+        mandatory?: boolean;
+    }>;
+}
+/**
+ * {@link ObjectMeta} property names removed when building {@link ObjectMetaUpsert} / `Connection.metaUpsert`
+ * payloads. Append when adding read-only or client-only fields on {@link ObjectMeta}.
+ */
+export declare const OBJECT_META_UPSERT_EXCLUDED_KEYS: readonly ["customIndexes", "settingsValues"];
+export type ObjectMetaUpsertExcludedKeys = (typeof OBJECT_META_UPSERT_EXCLUDED_KEYS)[number];
+/**
+ * Structure used when a script modifies object definition via `Connection.metaUpsert` — {@link ObjectMeta}
+ * minus {@link ObjectMetaUpsertExcludedKeys}.
+ */
+export type ObjectMetaUpsert = Omit<ObjectMeta, ObjectMetaUpsertExcludedKeys>;
+/** Structure used when a script modifies object settings values via `Connection.metaUpsert` */
+export interface ObjectSettingsValuesUpsert {
+    /** id of the object whose settings values are to be updated */
+    id: string;
+    /** new settings values to replace ALL current settings, full replacement so all values must be provided */
+    values: Record<string, unknown>;
+}
+/** ObjectField holds a field definition. */
+export interface ObjectField {
+    /** id of the property in the json response  */
+    id: string;
+    /** data type of the json property value  */
+    type: "any" | "string" | "number" | "boolean" | "object" | "file" | "array";
+    /** display label for the field  */
+    name?: string;
+    /** field holds the row unique identifier, required for update operations */
+    isKey?: boolean;
+    /** field holds an object containing the user defined row unique identifier required for add an update operations, and an indication of the operation type */
+    isUserKey?: boolean;
+    /** field, and any fields below, are custom (account specific) */
+    isCustom?: boolean;
+    /** can this field be referenced in match rules? */
+    canMatch?: boolean;
+    /** for picklist fields, this holds the allowed options */
+    optionValues?: ObjectFieldOption[];
+    /** for picklist fields, can options be added/updated? */
+    canUpdateOptions?: boolean;
+    /** field constraints */
+    constraints?: ObjectFieldConstraints;
+    /** for object fields, these are the properties of the object */
+    objectFields?: ObjectField[];
+    /** for array fields, this is the type of each array element */
+    arrayType?: "any" | "string" | "number" | "boolean" | "object" | "file" | "array";
+    /** for array fields of type object, these are the properties of each array element */
+    arrayObjectFields?: ObjectField[];
+    /** for flat file objects this holds extra details applicable to the generic flat-file connector */
+    flatFile?: {
+        /** how are arrays serialized/deserialized? (default: delimited) */
+        arrayFormat?: "delimited" | "json";
+        /** delimiter used to separate array elements (default: comma) */
+        arrayDelimiter?: string;
+        /** indicates the field contains the last modified date/time used for checkpointing (expects ISO8601 format, override using a constraint) */
+        isLastModified?: boolean;
+    };
+    /** 'data' may hold a small amount of info for connector-internal logic to reference */
+    data?: any;
+    format?: string;
+    export?: boolean;
+}
+/** FieldType expresses the allowed types of fields.  Not used in ObjectField as this improves intellisense */
+export type FieldType = "any" | "string" | "number" | "boolean" | "object" | "file" | "array";
+/** RowFilterType expresses the allowed types of filters.  Not used in ObjectField as this improves intellisense */
+export type RowFilterType = "string" | "number" | "boolean" | "object";
+/**
+ * ObjectFieldOption holds details of a valid option value for a field (e.g. useful for validating user input)
+ * on a object
+ */
+export interface ObjectFieldOption {
+    id: string;
+    name?: string;
+    group?: string;
+}
+/** ObjectFieldConstraints holds details of expected/allowed values for a field. */
+export interface ObjectFieldConstraints {
+    mandatory?: "always" | "add" | "update";
+    mandatoryAccepts?: Array<"null" | "blank_string">;
+    max?: number;
+    min?: number;
+    maxLen?: number;
+    minLen?: number;
+    trim?: boolean;
+    dt?: {
+        format?: "unix" | "unix_ms" | "iso8601" | "yyyy-MM-dd" | "M/d/yyyy" | "dd/MM/yyyy" | "yyyy-MM-dd HH:mm:ss" | "custom";
+        pattern?: string;
+        rangeYears?: number;
+        future?: boolean;
+        past?: boolean;
+        weekday?: boolean;
+        from?: string;
+        to?: string;
+    };
+    integer?: boolean;
+    decimals?: number;
+    regex?: string;
+    email?: boolean;
+}
+/** UpsertFieldOptionMeta is metadata describing a field 'option' value. */
+export interface UpsertFieldOptionMeta {
+    name?: string;
+    order?: string;
+    pipeline?: string;
+    probability?: string;
+}
+/** UpsertCleanOptions holds the upsert record and options to control the process. */
+export interface UpsertCleanOptions {
+    /** upsert row to be be cleaned & upserted (blank means send all pending rows) */
+    upsert?: any;
+    /** current row in query response format (used to detect whether the row contains any changes) */
+    current?: API.Row;
+    /** the number of rows to collect into a batch before performing the upsert (default is 1)*/
+    batchSize?: number;
+    optionFields?: {
+        /** selected option fields will have their metadata (available options) adjusted when new/changed values are found in the upsert row */
+        fixSelected: Array<string[]>;
+        /** this optional function can provide other metadata that may be required when creating/updating the given option id in the field (e.g. the name/display label for the id) */
+        meta?: (fieldPath: string[], id: string) => UpsertFieldOptionMeta;
+    };
+    issues?: {
+        /** upsert field to populate with details of issues found during the clean process */
+        field?: {
+            path?: string[];
+            jsonPath?: string;
+        };
+        /** details of issues that were cleansed (resolved) by external logic prior to calling upsertClean */
+        external?: UpsertIssue[];
+        /** seperator to place between each issue (default: "; ") */
+        seperator?: string;
+    };
+}
+/** UpsertCleanResponse is returned from the upsertClean function. */
+export interface UpsertCleanResponse {
+    /** indicates that changes were detected (ie. the row needed to be upserted) */
+    hasChanges: boolean;
+    /** indicates that the row cannot be upserted due to a fatal issue */
+    hasFatalIssues: boolean;
+    /** summary of the first change identified */
+    change?: {
+        field: string;
+        oldValue?: string;
+        newValue?: string;
+    };
+    /** details of issues (includes any issues that were 'cleansed' to resolve) */
+    issues: UpsertIssue[];
+    /** row(s) returned from the batched upsert requests */
+    rows?: API.Row[];
+}
+/** UpsertIssue has details of an issue found within an upsert request. */
+export interface UpsertIssue {
+    /** type of issue */
+    type: UpsertIssueType;
+    /** fatal issues block the row from being written to the destination */
+    fatal?: boolean;
+    /** path to the field that caused the issue */
+    fieldPath?: string[];
+    /** value that caused the issue */
+    value?: any;
+    /** option that caused the issue */
+    option?: {
+        id: string;
+        meta?: UpsertFieldOptionMeta;
+    };
+}
+/** UpsertIssueType is the type of issue found in an upsert request. */
+export type UpsertIssueType = "External" | "RowCleanFailed" | "OptionNotFound" | "OptionNameUpdateRequired" | "OptionNameUpdateConflict" | "ValueRequired" | "AboveMax" | "BelowMin" | "DateTimeFormat" | "WeekdayExpected" | "Trimmed" | "IntegerExpected" | "DecimalRounded" | "NotNumber" | "Regex" | "EmailInvalid" | "EmailConflict" | "ValueInvalid" | "MaxLength" | "MinLength";
+/** Specification of the relationship from one object to another. */
+export interface ObjectRelationship {
+    /** id for the relationship to the other object (must be unique on this object) */
+    id: string;
+    /** display label for the relationship (defaults to the id) */
+    name?: string;
+    /** object id of the other object that has a relationship to this object */
+    relObjectId: string;
+    /** maximum number of related rows on that may be returned when this relation is queried for a given row on this object */
+    cardinality: "OneToOne" | "OneToMany";
+    /** if the relationship is a foreign key, path to the field that holds the key (see fkPathOn for which object) */
+    fkPath?: Array<API.JsonValuePathPart>;
+    /** where fkPath is evaluated: this (default) = source object; related = relObjectId object */
+    fkPathOn?: "this" | "related";
+    /** connector may store extra info here */
+    data?: any;
+}
+/** IndexType holds a data index definition */
+export type IndexType = "unknown" | "jsonpath expression";
+/** ObjectIndex specifies an index to be added to cached connector data. */
+export interface ObjectIndex {
+    name: string;
+    type: IndexType;
+    path?: string[];
+    pattern?: string;
+}

package/lib/context.d.ts

@@ -0,0 +1,58 @@
+import { Connection } from "./connection.js";
+import { SyncGroup } from "./sync-group.js";
+import { Logger } from "./logger.js";
+import { FileProvider } from "./utilities/file-provider/file-provider.js";
+/** Context is passed to the script to provide access to system services such as logging, connections, state and environment information */
+export interface Context {
+    log: Logger;
+    parameters: {
+        [name: string]: any;
+    };
+    connections: {
+        [name: string]: () => Promise<Connection>;
+    };
+    syncGroups: {
+        [name: string]: () => Promise<SyncGroup>;
+    };
+    state: {
+        get(): Promise<any>;
+        set(state: any): Promise<void>;
+    };
+    feedback(options: {
+        percent: number;
+        code: string;
+        args?: string[];
+    }): void;
+    sendEmail(options: {
+        to: string[];
+        subject: string;
+        bodyHtml: string;
+        attachments?: Array<{
+            name: string;
+            file: FileProvider;
+        }>;
+    }): Promise<void>;
+    account: {
+        executions: {
+            list: (options: {
+                startTimeFrom?: Date;
+                startTimeTo?: Date;
+                minimumDurationSec?: number;
+            }) => AsyncIterableIterator<Execution>;
+        };
+    };
+    environment: {
+        engineUid: string;
+    };
+}
+export interface Execution {
+    id: string;
+    name: string;
+    complete: boolean;
+    startTime?: string;
+    durationSec?: number;
+    success?: boolean;
+    result?: any;
+    errorMessage?: string;
+    exitCode?: string;
+}

package/lib/environment.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Environment is presented to the hosting platform
+ */
+export declare function reset(): Promise<void>;

package/lib/logger.d.ts

@@ -0,0 +1,20 @@
+export interface Logger {
+    info(message: string, props?: unknown): void;
+    error(message: string | Error, props?: unknown): void;
+    context(): EventContext;
+}
+export interface EventContext {
+    scriptId?: string;
+    groupId?: string;
+    syncId?: string;
+    connectionId?: string;
+    objectId?: string;
+    rowKey?: string;
+    groupUID?: string;
+    syncUID?: string;
+    childSyncUID?: string;
+    syncProgressUID?: string;
+    queryUID?: string;
+    upsertUID?: string;
+    deleteUID?: string;
+}