@syncmatters/script-api 1.0.0

package/sdk-test/sdk-test.d.ts

@@ -0,0 +1,451 @@
+import API from "../index.js";
+/** This interface should be implemented in order for the test harness to run automated tests for the connector. */
+export interface TestFeatureProvider {
+    /** Identity of the connection will be verified to ensure testing happens against the expected connection. */
+    expectedIdentity: string;
+    /** Setup function to run before starting tests. Can perform any required setup, such as creating test data. */
+    before(options: BeforeOptions): Promise<void>;
+    /** Ids of all objects that have tests specs defined. */
+    objectIds(): Promise<string[]>;
+    /** Return the expected features for an object. */
+    objectFeatures(objectId: string): Promise<ObjectFeatures>;
+    /**
+     * Prepare data that will be used to test the list feature. The test data may be created here, or retrieved from the system.
+     * Returning undefined indicates that the harness should just execute the list operation and verify that some data is
+     * returned.
+     */
+    listPrepare?(options: ListOptions): Promise<ListData | undefined>;
+    /** Delete test data created for use by this test. */
+    listCleanup?(options: ListCleanupOptions): Promise<void>;
+    /**
+     * Prepare data that will be used to test the idsFilter. The test data may be created here, or retrieved from the system.
+     * If the object supports list queries, this method need not be implemented. If undefined is returned a list query will be
+     * attempted to find some ids to test. If no data is retrieved feature will be marked as failed, with no test data.
+     */
+    idsFilterPrepare?(options: IdsFilterOptions): Promise<IdsFilterData | undefined>;
+    /** Delete test data created for use by this test. */
+    idsFilterCleanup?(options: IdsFilterCleanupOptions): Promise<void>;
+    /**
+     * Prepare data that can be used to test the checkpoint filter. The test data may be created here, or retrieved from the
+     * system. Returning undefined indicates that checkpoint filters cannot be tested.
+     */
+    checkpointFilterStep1Prepare?(options: CheckpointStep1Options): Promise<CheckpointStep1Data | undefined>;
+    /**
+     * Prepare data that can be used to test the checkpoint filter a second time. The test data may be created here, or retrieved
+     * from the system. Returning undefined indicates that checkpoint filters cannot be tested.
+     */
+    checkpointFilterStep2Prepare?(options: CheckpointStep2Options): Promise<CheckpointStep2Data | undefined>;
+    /** Delete test data created for use by a test. */
+    checkpointFilterCleanup?(options: CheckpointCleanupOptions): Promise<void>;
+    /**
+     * Prepare data that can be used to test a match operation; you may either create new test data, or search/find data
+     * that can be used to test the match rule. Returning undefined indicates that this match rule cannot be tested.
+     */
+    matchFilterPrepare?(options: MatchOptions): Promise<Array<MatchData> | undefined>;
+    /** Delete test data created for use by a test. */
+    matchFilterCleanup?(options: MatchCleanupOptions): Promise<void>;
+    /**
+     * Prepare data that can be used to test a query related operation; you may either create new test data, or search/find data
+     * that can be used to test the relationship query. Returning undefined indicates that this relationship cannot be tested.
+     */
+    relatedFilterPrepare?(options: RelationshipOptions): Promise<Array<RelationshipData> | undefined>;
+    /** Delete test data created for use by a test. */
+    relatedFilterCleanup?(options: RelationshipCleanupOptions): Promise<void>;
+    /**
+     * Prepare data that can be used to test a queries with 'rowFilters'; you may either create new test data, or search/find
+     * data that can be used to test the various row filters. Include one test of of test data for each row filter. Returning
+     * undefined indicates that row filters cannot be tested.
+     */
+    rowFiltersPrepare?(options: RowFiltersOptions): Promise<Array<RowFilterData> | undefined>;
+    /** Delete test data created for use by a test. */
+    rowFiltersCleanup?(options: RowFiltersCleanupOptions): Promise<void>;
+    /** Prepare data that can be used in 1) an 'insert' operation, 2) a follow-up 'update' operation. The test harness will copy
+     * the id from the insert response into the update request. Returning undefined indicates that the requested insert/update
+     * operation cannot be tested. The callet may request that:
+     * - a file field be included in the upsert request
+     * - examples be provided to simulate each possible upsertClean issue that may be returned by the connector for this object
+     */
+    upsertPrepare?(options: UpsertOptions): Promise<UpsertData | undefined>;
+    /** Delete test data created for use by a test. */
+    upsertCleanup?(options: UpsertCleanupOptions): Promise<void>;
+    /** Optional teardown function to run after all tests have completed. Can perform any required teardown, such as deleting test
+     * data. */
+    after?(): Promise<void>;
+}
+/** Specification of features that are supported by an object; much of this is auto generated however particular
+ * features may be further refined/specified by the test harness.
+ */
+export interface ObjectFeatures {
+    /** If this object is exactly the same (i.e. 100% same code, same features) as another object on this connector, there is no
+     * need to test the object - just enter the id of the other object here.
+     */
+    sameAsObjectId?: string;
+    /** If this object cannot be tested, provide a reason here. For example "Object not available on test account". When a value
+     * is specified no object features will not be tested; the object status will be set to "Not tested".
+     */
+    cannotTestReason?: string;
+    query?: {
+        /** This option is as-per the object level sameAsObjectId, however applied at the whole of query operation */
+        sameAsObjectId?: string;
+        /** This option is as-per the object level cannotTestReason, however applied at the whole of query operation */
+        cannotTestReason?: string;
+        /** Does the object support list queries? (queries with no filters to return a all rows) */
+        list?: boolean;
+        /** This option is as-per the object level sameAsObjectId, however applied at the list query operation */
+        listSameAsObjectId?: string;
+        /** This option is as-per the object level cannotTestReason, however applied at the list query operation */
+        listCannotTestReason?: string;
+        /** Does the object allow rows to be collected by id? */
+        idsFilter?: boolean;
+        /** This option is as-per the object level sameAsObjectId, however applied at the idsFilter operation */
+        idsFilterSameAsObjectId?: string;
+        /** This option is as-per the object level cannotTestReason, however applied at the idsFilter operation */
+        idsFilterCannotTestReason?: string;
+        /** Does the object support checkpoint filtering? */
+        checkpointFilter?: boolean;
+        /** This option is as-per the object level sameAsObjectId, however applied at the checkpointFilter operation */
+        checkpointFilterSameAsObjectId?: string;
+        /** This option is as-per the object level cannotTestReason, however applied at the checkpointFilter operation */
+        checkpointFilterCannotTestReason?: string;
+        /** Expected match rules. Use sameAsObjectId or cannotTestReason to record reason not to test a match rule. */
+        matchRules?: {
+            rule: API.RowMatchRuleType;
+            sameAsObjectId?: string;
+            cannotTestReason?: string;
+        }[];
+        /** This option is as-per the object level sameAsObjectId, however applied to all match rule operations */
+        matchRulesSameAsObjectId?: string;
+        /** This option is as-per the object level cannotTestReason, however applied to all match rule operations */
+        matchRulesCannotTestReason?: string;
+        /** Which fields can be used for matching (typically means the API allows searching / filtering by the field) */
+        canMatchFields?: Array<API.JsonValuePath>;
+        /** Expected relationships to other objects. Use sameAsObjectId or cannotTestReason to record reason not to tested. */
+        relationshipsTo?: Array<{
+            id: string;
+            relObjectId: string;
+            sameAsObjectId?: string;
+            cannotTestReason?: string;
+        }>;
+        /** This option is as-per the object level sameAsObjectId, however applied to all relationship operations */
+        relationshipsToSameAsObjectId?: string;
+        /** This option is as-per the object level cannotTestReason, however applied to all relationship operations */
+        relationshipsToCannotTestReason?: string;
+    };
+    upsert?: {
+        /** This option is as-per the object level sameAsObjectId, however applied at the upsert operation */
+        sameAsObjectId?: string;
+        /** This option is as-per the object level cannotTestReason, however applied at the upsert operation */
+        cannotTestReason?: string;
+        /** Can rows be added/updated? */
+        canUpsert?: boolean;
+        key?: {
+            /** Path to the key in upsert fields */
+            path?: API.JsonValuePath;
+            /** Is this key user defined? (i.e. included on add and update)? */
+            expectUserKey?: boolean;
+        };
+        /** Is upsertClean supported? */
+        canUpsertClean?: boolean;
+        /** This option is as-per the object level sameAsObjectId, however applied at the upsertFieldOptions operation */
+        upsertCleanSameAsObjectId?: string;
+        /** This option is as-per the object level cannotTestReason, however applied at the upsertFieldOptions operation */
+        upsertCleanCannotTestReason?: string;
+        /** Can selected picklist option fields have new options auto-added and updated? */
+        canUpsertFieldOptions?: boolean;
+        /** Can custom relationships be added? */
+        canAddCustomRelationships?: boolean;
+        /** This option is as-per the object level sameAsObjectId, however applied at the upsertFieldOptions operation */
+        upsertFieldOptionsSameAsObjectId?: string;
+        /** This option is as-per the object level cannotTestReason, however applied at the upsertFieldOptions operation */
+        upsertFieldOptionsCannotTestReason?: string;
+        /** Identify expected field constraints */
+        constraints?: Array<{
+            fieldPath: API.JsonValuePath;
+            constraints: API.ObjectFieldConstraints;
+        }>;
+    };
+    delete?: {
+        /** This option is as-per the object level sameAsObjectId, however applied at the upsert operation */
+        sameAsObjectId?: string;
+        /** This option is as-per the object level cannotTestReason, however applied at the upsert operation */
+        cannotTestReason?: string;
+        /** Can rows be deleted? */
+        canDelete?: boolean;
+        key?: {
+            /** Path to the key in delete fields */
+            path?: API.JsonValuePath;
+        };
+        isDeleted?: {
+            /** Does the api still return the row, with this field set to valueWhenDeleted, even after deletion? */
+            path?: API.JsonValuePath;
+            valueWhenDeleted?: unknown;
+        };
+        /** After a delete, it may take up to this long before the API reports the row as deleted */
+        afterDeleteMaxIndexWaitTimeMs?: number;
+    };
+}
+/** List of features that can be tested for an object. */
+export type ObjectFeature = "all" | "list" | "idsFilter" | "fieldMetadata" | "checkpointFilter" | "relatedFilter" | "matchFilter" | "upsert" | "upsertClean" | "delete" | "rowFilter";
+export interface BeforeOptions {
+    /** Connection that will be used to test the connector logic, as selected by the user. */
+    connection: unknown;
+    /** Logger to use for logging. */
+    log: API.Logger;
+}
+/** Result of testing a connector. */
+export interface ConnectorTestResult {
+    summaryStatus?: "Passed" | "Partial: Only selected objects/features tested" | "Partial: Not all features/objects can be tested" | "Failed: Connection selected for testing not found" | "Failed: Cannot create an instance of the test connection" | "Failed: Cannot instantiate the selected test code file" | "Failed: One or more tests failed";
+    fatalError?: CaughtError;
+    metaRefresh?: "Passed" | "Not supported" | "Not tested" | "Failed: Fatal error during testing" | "Failed: Connection identity does not match the test spec";
+    testConnection?: "Passed" | "Not tested" | "Failed: Fatal error during testing" | "Failed: Test connection response did not report success";
+    objectsStatus?: "Passed" | "Partial: Only selected objects tested" | "Partial: Only selected objects tested, not all features can be tested" | "Partial: Only selected object tests run" | "Partial: Only selected objects tested, only selected object tests run" | "Partial: Not all features/objects can be tested" | "Not tested" | "Failed: Fatal error during testing" | "Failed: One or more objects failed tests";
+    objects: ObjectTestResult[];
+}
+export interface ObjectTestResult {
+    objectId: string;
+    summaryStatus?: "Passed" | "Partial: Only selected object tests run" | "Partial: Not all features can be tested" | "Not tested" | "Failed: Object has no test spec" | "Failed: 'Same as object' not tested" | "Failed: Fatal error during testing" | "Failed: Object from test spec not present on connection" | "Failed: One or more tests failed";
+    fatalError?: CaughtError;
+    notTestedSameAsObjectId?: string;
+    notTestedReason?: string;
+    list?: "Passed" | "Passed: Limited test data, pagination not tested" | "Not tested" | "Not supported" | "Failed: 'Same as object' not tested" | "Failed: Object metadata supports list, test spec does not" | "Failed: Test spec supports list, object metadata does not" | "Failed: Fatal error during testing" | "Failed: No test data";
+    listNotTestedSameAsObjectId?: string;
+    listNotTestedReason?: string;
+    listFatalError?: CaughtError;
+    idsFilter?: "Passed" | "Not tested" | "Not supported" | "Failed: 'Same as object' not tested" | "Failed: Object metadata supports idsFilter, test spec does not" | "Failed: Test spec supports idsFilter, object metadata does not" | "Failed: Fatal error during testing" | "Failed: No test data" | "Failed: Returned unexpected row" | "Failed: Row not returned" | "Failed: More rows returned than expected";
+    idsFilterNotTestedSameAsObjectId?: string;
+    idsFilterNotTestedReason?: string;
+    idsFilterFatalError?: CaughtError;
+    checkpointFilter?: "Passed" | "Not tested" | "Not supported" | "Failed: 'Same as object' not tested" | "Failed: Object metadata supports checkpointFilter, test spec does not" | "Failed: Test spec supports checkpointFilter, object metadata does not" | "Failed: Fatal error during testing" | "Failed: No test data for step 1" | "Failed: No test data for step 2" | "Failed: Returned unexpected row for step 1" | "Failed: Returned unexpected row for step 2" | "Failed: Row not returned for step 1" | "Failed: Row not returned for step 2" | "Failed: Next checkpoint not returned";
+    checkpointFilterNotTestedSameAsObjectId?: string;
+    checkpointFilterNotTestedReason?: string;
+    checkpointFilterFatalError?: CaughtError;
+    relatedFilter?: "Passed" | "Not tested" | "Not supported" | "Failed: 'Same as object' not tested" | "Partial: Not all relationships can be tested" | "Failed: Object metadata supports relatedFilter, test spec does not" | "Failed: Test spec supports relatedFilter, object metadata does not" | "Failed: One or more filters have issues";
+    relatedFilterNotTestedSameAsObjectId?: string;
+    relatedFilterNotTestedReason?: string;
+    relatedFilterResults?: RelatedFilterTestResult[];
+    matchFilter?: "Passed" | "Not tested" | "Not supported" | "Failed: 'Same as object' not tested" | "Partial: Not all rules can be tested" | "Failed: Object metadata supports match rules, test spec does not" | "Failed: Test spec supports match rules, object metadata does not" | "Failed: One or more rules have issues";
+    matchFilterNotTestedSameAsObjectId?: string;
+    matchFilterNotTestedReason?: string;
+    matchFieldCount?: number;
+    matchFilterResults?: MatchRuleTestResult[];
+    upsert?: "Passed" | "Not tested" | "Not supported" | "Failed: 'Same as object' not tested" | "Failed: Feature has no test spec" | "Failed: Fatal error during testing" | "Failed: Test spec does not define key field" | "Failed: No test data for insert" | "Failed: No test data for update" | "Failed: No verifyField included with test data" | "Failed: query after insert did not return expected rows" | "Failed: No key path to test update" | "Failed: update returned unexpected row" | "Failed: verifyField value on the upsert row was blank" | "Failed: verifyField value on the queried row does not match the upsert value";
+    upsertNotTestedSameAsObjectId?: string;
+    upsertNotTestedReason?: string;
+    upsertFatalError?: CaughtError;
+    upsertClean?: "Passed" | "Not tested" | "Not supported" | "Failed: 'Same as object' not tested" | "Failed: constraints not defined" | "Failed: Feature has no test spec" | "Failed: ObjectFeatures says upsertClean is supported, however missing from object metadata" | "Failed: No test data for insert" | "Failed: No test data for simulating issues" | "Failed: Expected issue not reported by connector" | "Failed: Issue incorrectly reported as fatal by connector" | "Failed: Issue incorrectly reported as NOT fatal by connector" | "Failed: Fatal error during testing";
+    upsertCleanNotTestedSameAsObjectId?: string;
+    upsertCleanNotTestedReason?: string;
+    upsertCleanFatalError?: CaughtError;
+    fieldConstraintsCount?: number;
+    delete?: "Passed" | "Not tested" | "Not supported" | "Failed: 'Same as object' not tested" | "Failed: Feature has no test spec" | "Failed: Fatal error during testing" | "Failed: No test data for insert" | "Failed: insert did not return 2 rows" | "Failed: query after insert did not return expected rows" | "Failed: query after delete still returns row" | "Failed: No key path to test delete" | "Failed: delete returned unexpected row";
+    deleteNotTestedSameAsObjectId?: string;
+    deleteNotTestedReason?: string;
+    deleteFatalError?: CaughtError;
+    fieldMetadata?: "Passed" | "Not tested" | "Failed: One or more fields have metadata issues";
+    fieldMetadataIssues: FieldMetadataIssue[];
+}
+export interface FieldMetadataIssue {
+    operation: "query" | "upsert" | "delete";
+    path?: string;
+    issue: "Missing canMatch" | "No test spec for key field" | "Key field from test spec not found on object" | "Key field not tagged with isKey" | "Key field not tagged with isUserKey" | "Key field user key structure incorrect {value: string, operation: string}";
+}
+export interface MatchRuleTestResult {
+    rule: API.RowMatchRuleType;
+    status?: "Passed" | "Not tested" | "Failed: Rule has no test spec" | "Failed: Rule not present on object" | "Failed: Fatal error during testing" | "Failed: No test data" | "Failed: Expected match not returned" | "Failed: Wrong match returned" | "Failed: Test data invalid, no expected row ids";
+    notTestedSameAsObjectId?: string;
+    notTestedReason?: string;
+    errorRowId?: string;
+    fatalError?: CaughtError;
+}
+export interface RelatedFilterTestResult {
+    relationshipId: string;
+    status?: "Passed" | "Not tested" | "Failed: Relationship has no test spec" | "Failed: Relationship not present on object" | "Failed: Fatal error during testing" | "Failed: No test data" | "Failed: Did not find expected related row" | "Failed: Found unexpected row" | "Failed: Test data invalid, no expected row ids" | "Failed: Test data invalid, 'from' row not returned via idsFilter";
+    notTestedSameAsObjectId?: string;
+    notTestedReason?: string;
+    errorRowId?: string;
+    fatalError?: CaughtError;
+}
+/** Details from caught error that blocked test completion */
+export interface CaughtError {
+    message?: string;
+    stack?: string;
+}
+/** Options passed when requesting data that will be used for an upsert test. */
+export interface UpsertOptions {
+    meta: API.ObjectMeta;
+    withIssueSimulators?: boolean;
+    withUpsertFieldOptions?: API.JsonValuePath;
+    withFileField?: API.JsonValuePath;
+}
+/** Options passed when cleaning up after an upsert test. */
+export interface UpsertCleanupOptions {
+    meta: API.ObjectMeta;
+    inserted: Array<API.Row>;
+}
+/** Data returned when requesting data that will be used for an upsert test. */
+export interface UpsertData {
+    /** data to pass in the upsert call (ideally for an add operation) */
+    insert?: unknown;
+    /** a simple update that may be made to the added row (the test harness will copy over the key from the add response) */
+    update?: unknown;
+    /** if requested, include 'bad data' examples that will trigger upsertClean issues */
+    issueSimulators?: Array<UpsertIssueSimulator>;
+    /** fields to check to verify the insert/update was successful */
+    verifyFields?: Array<API.JsonValuePath>;
+    /** optionally specify other fields to include when querying the data back for validation */
+    fields?: Array<API.JsonValuePath>;
+}
+/** Expresses how to simulate an upsertClean issue, and defines the expected response. */
+export interface UpsertIssueSimulator {
+    /** field(s) to apply to the insert to simulate the issue */
+    upsert: unknown;
+    /** expected upsert issue type */
+    type: API.UpsertIssueType;
+    /** is the issue expected to be fatal */
+    fatal?: boolean;
+}
+/** Options passed when requesting data that will be used for a match test. */
+export interface MatchOptions {
+    meta: API.ObjectMeta;
+    rule: API.RowMatchRuleType;
+}
+/** Options passed when cleaning up after a match test. */
+export interface MatchCleanupOptions {
+    meta: API.ObjectMeta;
+    testData: Array<MatchData>;
+}
+/** Data returned when requesting data that will be used for a match test. */
+export interface MatchData {
+    /** data to pass into the match filter */
+    srcData: API.RowMatchData[];
+    /** path to the field on the dest row that holds the field to match with, if applicable to the rule */
+    destFieldPath?: API.JsonValuePath;
+    /** ids of dest rows expected back in response to the match query */
+    expectedMatchRowIds: string[];
+    /** optionally specify the fields to include in the match query */
+    fields?: Array<API.JsonValuePath>;
+}
+/** Options passed when requesting data that will be used for a relationship test. */
+export interface RelationshipOptions {
+    fromObjectMeta: API.ObjectMeta;
+    fromRelationshipId: string;
+    toObjectMeta: API.ObjectMeta;
+}
+/** Options passed when cleaning up after a relationship test. */
+export interface RelationshipCleanupOptions {
+    fromObjectMeta: API.ObjectMeta;
+    fromRelationshipId: string;
+    toObjectMeta: API.ObjectMeta;
+    testDatas: Array<RelationshipData>;
+}
+/** Data returned when requesting data that will be used for a relationship test. */
+export interface RelationshipData {
+    /** id of the source row that will be passed as a filter when querying for rows from the 'other' object */
+    srcRowId: string;
+    /** id of rows from the 'other' object we can expect in response */
+    expectedRelatedRowIds: string[];
+    /** optionally specify the fields to include when collecting the 'from' row */
+    srcFields?: Array<API.JsonValuePath>;
+    /** optionally specify the fields from the 'other' row that should be returned in the response */
+    relatedFields?: Array<API.JsonValuePath>;
+}
+/** Options passed when requesting data that will be used for a checkpoint test. */
+export interface CheckpointStep1Options {
+    meta: API.ObjectMeta;
+}
+/** Options passed when requesting data that will be used for a checkpoint test. */
+export interface CheckpointStep2Options {
+    meta: API.ObjectMeta;
+    step1TestData: CheckpointStep1Data;
+    checkpointReceived: string;
+}
+/** Options passed when cleaning up after a checkpoint test. */
+export interface CheckpointCleanupOptions {
+    meta: API.ObjectMeta;
+    step1TestData: CheckpointStep1Data;
+    step2TestData: CheckpointStep2Data;
+}
+/** Data returned when requesting data that will be used for a checkpoint test. */
+export interface CheckpointStep1Data {
+    /** checkpoint to pass in the first checkpoint query */
+    nextCheckpoint?: string;
+    /** optional limit to pass in the first checkpoint query */
+    limit?: number;
+    /** id of rows we should receive back in response to the first checkpoint query */
+    expectedRowIds: string[];
+    /** optionally specify the fields to include in the checkpoint query */
+    fields?: Array<API.JsonValuePath>;
+}
+export interface CheckpointStep2Data {
+    /** id of rows we should receive back in response to the second checkpoint query */
+    expectedRowIds: string[];
+    /** optionally specify the fields to include in the checkpoint query */
+    fields?: Array<API.JsonValuePath>;
+}
+/** Options passed when requesting data that will be used for an list test. */
+export interface ListOptions {
+    meta: API.ObjectMeta;
+}
+/** Options passed when cleaning up after an list test. */
+export interface ListCleanupOptions {
+    meta: API.ObjectMeta;
+    testData: ListData;
+}
+/** Data returned when requesting data that will be used for an list test. */
+export interface ListData {
+    /** number of rows included in each page of data returned via a list query, user to test pagination */
+    pageSize: number;
+    /** optionally specify the fields to include in the list query */
+    fields?: Array<API.JsonValuePath>;
+    /** if the test harness created test data, place the ids of the rows created here */
+    rowIds?: string[];
+}
+/** Options passed when requesting data that will be used for an idsFilter test. */
+export interface IdsFilterOptions {
+    meta: API.ObjectMeta;
+}
+/** Options passed when cleaning up after an idsFilter test. */
+export interface IdsFilterCleanupOptions {
+    meta: API.ObjectMeta;
+    testData: IdsFilterData;
+}
+/** Data returned when requesting data that will be used for an idsFilter test. */
+export interface IdsFilterData {
+    id1: string;
+    id2: string;
+    /** optionally specify the fields to include in the idsFilter query */
+    fields?: Array<API.JsonValuePath>;
+}
+/** Options passed when requesting data that will be used for a rowFilters test. */
+export interface RowFiltersOptions {
+    meta: API.ObjectMeta;
+}
+/** Options passed when cleaning up after an idsFilter test. */
+export interface RowFiltersCleanupOptions {
+    meta: API.ObjectMeta;
+    testData: Array<RowFilterData>;
+}
+/** Data returned when requesting data that will be used for rowFilters tests. */
+export interface RowFilterData {
+    /** filter to be passed in the query */
+    rowFilter: unknown;
+    /** id of rows we can expect in response */
+    expectedRowIds: string[];
+    /** optionally specify the fields to include in the rowFilter query */
+    fields?: Array<API.JsonValuePath>;
+}
+/**
+ * Find object field metadata by path.
+ * @param {API.ObjectField[]} fields
+ * @param {API.JsonValuePath} path - e.g. [{path: "id"}]
+ * @returns API.ObjectField|undefined
+ */
+export declare function findObjectField(fields?: API.ObjectField[], path?: API.JsonValuePath): API.ObjectField | undefined;
+/**
+ * Make a 6-character unique id for a test, e.g to use in naming test data. The unique id is guaranteed to be unique
+ * across this process. Uses a 3-letter random prefix + 3-character base36 counter. When counter overflows,
+ * generates a new unused 3-letter prefix. Whilst the uid will be unique for a given test run, it is possible that
+ * the uid will not be unique across test runs.
+ * @returns A unique id for a test.
+ */
+export declare function makeUid(): string;

package/sdk-test.d.ts

@@ -0,0 +1,3 @@
+import * as SDKTest from "./sdk-test/sdk-test.js";
+export * from "./sdk-test/sdk-test.js";
+export default SDKTest;