electrodb 3.6.2 → 3.7.0

package/dist/index.test-d.js

@@ -1,4043 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = require("./");
-const tsd_1 = require("tsd");
-require("./test/tests.test-d");
-const magnify = (value) => {
-    return value;
-};
-let entityWithSK = new _1.Entity({
-    model: {
-        entity: "abc",
-        service: "myservice",
-        version: "myversion",
-    },
-    attributes: {
-        attr1: {
-            type: "string",
-            default: "abc",
-            get: (val) => val + 123,
-            set: (val) => (val ?? "") + 456,
-            validate: (val) => !!val,
-        },
-        attr2: {
-            type: "string",
-            // default: () => "sfg",
-            // required: false,
-            validate: (val) => val.length > 0,
-        },
-        attr3: {
-            type: ["123", "def", "ghi"],
-            default: "def",
-        },
-        attr4: {
-            type: ["abc", "ghi"],
-            required: true,
-        },
-        attr5: {
-            type: "string",
-        },
-        attr6: {
-            type: "number",
-            default: () => 100,
-            get: (val) => val + 5,
-            set: (val) => (val ?? 0) + 5,
-            validate: (val) => true,
-        },
-        attr7: {
-            type: "any",
-            default: () => false,
-            get: (val) => ({ key: "value" }),
-            set: (val) => (val ?? 0) + 5,
-            validate: (val) => true,
-        },
-        attr8: {
-            type: "boolean",
-            required: true,
-            get: (val) => !!val,
-            set: (val) => !!val,
-            validate: (val) => !!val,
-        },
-        attr9: {
-            type: "number",
-        },
-        attr10: {
-            type: "boolean",
-        },
-    },
-    indexes: {
-        myIndex: {
-            collection: "mycollection2",
-            pk: {
-                field: "pk",
-                composite: ["attr1"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["attr2"],
-            },
-        },
-        myIndex2: {
-            collection: "mycollection1",
-            index: "gsi1",
-            pk: {
-                field: "gsipk1",
-                composite: ["attr6", "attr9"],
-            },
-            sk: {
-                field: "gsisk1",
-                composite: ["attr4", "attr5"],
-            },
-        },
-        myIndex3: {
-            collection: "mycollection",
-            index: "gsi2",
-            pk: {
-                field: "gsipk2",
-                composite: ["attr5"],
-            },
-            sk: {
-                field: "gsisk2",
-                composite: ["attr4", "attr3", "attr9"],
-            },
-        },
-    },
-});
-let entityWithoutSK = new _1.Entity({
-    model: {
-        entity: "abc",
-        service: "myservice",
-        version: "myversion",
-    },
-    attributes: {
-        attr1: {
-            type: "string",
-            // default: "abc",
-            get: (val) => val + 123,
-            set: (val) => (val ?? "0") + 456,
-            validate: (val) => !!val,
-        },
-        attr2: {
-            type: "string",
-            // default: () => "sfg",
-            // required: false,
-            validate: (val) => val.length > 0,
-        },
-        attr3: {
-            type: ["123", "def", "ghi"],
-            default: "def",
-        },
-        attr4: {
-            type: ["abc", "def"],
-            required: true,
-        },
-        attr5: {
-            type: "string",
-        },
-        attr6: {
-            type: "number",
-            default: () => 100,
-            get: (val) => val + 5,
-            set: (val) => (val ?? 0) + 5,
-            validate: (val) => true,
-        },
-        attr7: {
-            type: "any",
-            default: () => false,
-            get: (val) => ({ key: "value" }),
-            set: (val) => (val ?? 0) + 5,
-            validate: (val) => true,
-        },
-        attr8: {
-            type: "boolean",
-            required: true,
-            default: () => false,
-            get: (val) => !!val,
-            set: (val) => !!val,
-            validate: (val) => !!val,
-        },
-        attr9: {
-            type: "number",
-        },
-    },
-    indexes: {
-        myIndex: {
-            pk: {
-                field: "pk",
-                composite: ["attr1"],
-            },
-        },
-        myIndex2: {
-            index: "gsi1",
-            collection: "mycollection1",
-            pk: {
-                field: "gsipk1",
-                composite: ["attr6", "attr9"],
-            },
-            sk: {
-                field: "gsisk1",
-                composite: [],
-            },
-        },
-        myIndex3: {
-            collection: "mycollection",
-            index: "gsi2",
-            pk: {
-                field: "gsipk2",
-                composite: ["attr5"],
-            },
-            sk: {
-                field: "gsisk2",
-                composite: [],
-            },
-        },
-    },
-});
-let standAloneEntity = new _1.Entity({
-    model: {
-        entity: "standalone",
-        service: "myservice",
-        version: "1",
-    },
-    attributes: {
-        prop1: {
-            type: "string",
-            default: "abc",
-        },
-        prop2: {
-            type: "string",
-        },
-        prop3: {
-            type: "string",
-        },
-    },
-    indexes: {
-        index1: {
-            pk: {
-                field: "pk",
-                composite: ["prop1", "prop2"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["prop3"],
-            },
-        },
-    },
-});
-let normalEntity1 = new _1.Entity({
-    model: {
-        entity: "normalEntity1",
-        service: "myservice",
-        version: "1",
-    },
-    attributes: {
-        prop1: {
-            type: "string",
-            default: "abc",
-        },
-        prop2: {
-            type: "string",
-        },
-        prop3: {
-            type: "string",
-            required: true,
-        },
-        prop4: {
-            type: "number",
-        },
-        prop10: {
-            type: "boolean",
-        },
-    },
-    indexes: {
-        tableIndex: {
-            collection: "normalcollection",
-            pk: {
-                field: "pk",
-                composite: ["prop1", "prop2"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["prop4"],
-            },
-        },
-    },
-});
-let normalEntity2 = new _1.Entity({
-    model: {
-        entity: "normalEntity2",
-        service: "myservice",
-        version: "1",
-    },
-    attributes: {
-        prop1: {
-            type: "string",
-        },
-        prop2: {
-            type: "string",
-        },
-        prop3: {
-            type: "string",
-            required: true,
-        },
-        prop5: {
-            type: "number",
-        },
-        attr6: {
-            type: "number",
-            default: () => 100,
-            get: (val) => val + 5,
-            set: (val) => (val ?? 0) + 5,
-            validate: (val) => true,
-        },
-        attr9: {
-            type: "number",
-        },
-    },
-    indexes: {
-        indexTable: {
-            collection: "normalcollection",
-            pk: {
-                field: "pk",
-                composite: ["prop1", "prop2"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["prop5"],
-            },
-        },
-        anotherIndex: {
-            index: "gsi1",
-            collection: "mycollection1",
-            pk: {
-                field: "gsipk1",
-                composite: ["attr6", "attr9"],
-            },
-            sk: {
-                field: "gsisk1",
-                composite: [],
-            },
-        },
-    },
-});
-const item = {
-    attr1: "attr1",
-    attr2: "attr2",
-    attr3: "def",
-    attr4: "abc",
-    attr5: "attr5",
-    attr6: 123,
-    attr7: "attr7",
-    attr8: true,
-    attr9: 456,
-};
-const AttributeName = "";
-let getKeys = ((val) => { });
-/** Schema With SK **/
-// Get
-// Single
-entityWithSK.get({ attr1: "adg", attr2: "ada" });
-entityWithoutSK.get({ attr1: "abc" });
-(0, tsd_1.expectAssignable)([{ attr1: "abc", attr2: "abd" }]);
-(0, tsd_1.expectAssignable)([{ attr1: "abc" }]);
-// Invalid Get
-(0, tsd_1.expectError)([{}]);
-(0, tsd_1.expectError)([{ attr1: "sdggd" }]);
-(0, tsd_1.expectError)([{ attr2: "sdggd" }]);
-(0, tsd_1.expectError)({ attr1: 1324, attr2: "adsga" });
-(0, tsd_1.expectError)([{}]);
-(0, tsd_1.expectError)([{ attr2: "adsga" }]);
-(0, tsd_1.expectError)({ attr2: "adsga" });
-(0, tsd_1.expectError)({ attr1: 1324, attr2: "adsga" });
-let getSingleFinishersWithSK = getKeys(entityWithSK.get({ attr1: "abc", attr2: "24" }));
-let getBatchFinishersWithSK = getKeys(entityWithSK.get([{ attr1: "abc", attr2: "24" }]));
-let getSingleFinishersWithoutSK = getKeys(entityWithoutSK.get({ attr1: "abc" }));
-let getBatchFinishersWithoutSK = getKeys(entityWithoutSK.get([{ attr1: "abc" }]));
-(0, tsd_1.expectAssignable)(getSingleFinishersWithSK);
-(0, tsd_1.expectAssignable)(getBatchFinishersWithSK);
-(0, tsd_1.expectAssignable)(getSingleFinishersWithoutSK);
-(0, tsd_1.expectAssignable)(getBatchFinishersWithoutSK);
-entityWithSK
-    .get([{ attr1: "adg", attr2: "ada" }])
-    .go({ concurrent: 24, preserveBatchOrder: true });
-(0, tsd_1.expectError)(entityWithSK
-    .get([{ attr1: "adg", attr2: "ada" }])
-    .params({ concurrent: 24, preserveBatchOrder: true }));
-entityWithoutSK
-    .get([{ attr1: "adg" }])
-    .go({ concurrent: 24, preserveBatchOrder: true });
-(0, tsd_1.expectError)(entityWithoutSK
-    .get([{ attr1: "adg" }])
-    .params({ concurrent: 24, preserveBatchOrder: true }));
-let getSingleGoWithSK = entityWithSK.get({ attr1: "adg", attr2: "ada" }).go;
-let getSingleGoWithoutSK = entityWithoutSK.get({ attr1: "adg" }).go;
-let getSingleParamsWithSK = entityWithSK.get({
-    attr1: "adg",
-    attr2: "ada",
-}).params;
-let getSingleParamsWithoutSK = entityWithoutSK.get({ attr1: "adg" }).params;
-let getBatchGoWithSK = entityWithSK.get([{ attr1: "adg", attr2: "ada" }]).go;
-let getBatchGoWithoutSK = entityWithoutSK.get([{ attr1: "adg" }]).go;
-let getBatchParamsWithSK = entityWithSK.get([
-    { attr1: "adg", attr2: "ada" },
-]).params;
-let getBatchParamsWithoutSK = entityWithoutSK.get([{ attr1: "adg" }]).params;
-(0, tsd_1.expectAssignable)({
-    originalErr: true,
-    params: {},
-    table: "abc",
-});
-(0, tsd_1.expectAssignable)({
-    originalErr: true,
-    params: {},
-    table: "abc",
-});
-(0, tsd_1.expectAssignable)({
-    originalErr: true,
-    params: {},
-    table: "abc",
-});
-(0, tsd_1.expectAssignable)({
-    originalErr: true,
-    params: {},
-    table: "abc",
-});
-(0, tsd_1.expectError)({
-    concurrent: 10,
-    unprocessed: "raw",
-    preserveBatchOrder: true,
-});
-(0, tsd_1.expectError)({
-    concurrent: 10,
-    unprocessed: "raw",
-    preserveBatchOrder: true,
-});
-(0, tsd_1.expectError)({
-    concurrent: 10,
-    unprocessed: "raw",
-    preserveBatchOrder: true,
-});
-(0, tsd_1.expectError)({
-    concurrent: 10,
-    unprocessed: "raw",
-    preserveBatchOrder: true,
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectAssignable)({
-    originalErr: true,
-    params: {},
-    table: "abc",
-    attributes: ["attr1"],
-});
-(0, tsd_1.expectAssignable)({
-    originalErr: true,
-    params: {},
-    table: "abc",
-    attributes: ["attr1"],
-});
-(0, tsd_1.expectNotAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-    attributes: ["attrz1"],
-});
-(0, tsd_1.expectNotAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-    attributes: ["attrz1"],
-});
-(0, tsd_1.expectNotAssignable)({ attributes: ["attrz1"] });
-(0, tsd_1.expectNotAssignable)({ attributes: ["attrz1"] });
-(0, tsd_1.expectAssignable)(entityWithSK
-    .get({ attr1: "abc", attr2: "def" })
-    .go()
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithoutSK
-    .get({ attr1: "abc" })
-    .go()
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithSK.get({ attr1: "abc", attr2: "def" }).params());
-(0, tsd_1.expectAssignable)(entityWithoutSK.get({ attr1: "abc" }).params());
-(0, tsd_1.expectAssignable)(entityWithSK.scan
-    .go({ attributes: ["attr1", "attr2"] })
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithSK
-    .find({ attr10: true })
-    .go({ attributes: ["attr1", "attr7", "attr6"] })
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithSK
-    .match({ attr3: "def" })
-    .go({ attributes: ["attr4", "attr5"] })
-    .then((res) => res.data));
-entityWithSK
-    .get([{ attr1: "abc", attr2: "def" }])
-    .go()
-    .then((res) => {
-    const [item] = res.data;
-    const [unprocessed] = res.unprocessed;
-    (0, tsd_1.expectType)(item);
-    (0, tsd_1.expectType)(magnify(unprocessed));
-});
-entityWithSK
-    .get([{ attr1: "abc", attr2: "def" }])
-    .go({ preserveBatchOrder: true })
-    .then((res) => {
-    const item = magnify(res.data[0]);
-    const unprocessed = res.unprocessed[0];
-    (0, tsd_1.expectType)(item);
-    (0, tsd_1.expectType)(magnify(unprocessed));
-});
-entityWithSK
-    .get([{ attr1: "abc", attr2: "def" }])
-    .go()
-    .then((res) => {
-    (0, tsd_1.expectType)(magnify(res.data));
-    (0, tsd_1.expectType)(magnify(res.unprocessed));
-});
-entityWithSK
-    .get([{ attr1: "abc", attr2: "def" }])
-    .go()
-    .then(({ data, unprocessed }) => {
-    (0, tsd_1.expectAssignable)(data);
-    (0, tsd_1.expectAssignable)(unprocessed);
-});
-entityWithoutSK
-    .get([{ attr1: "abc" }])
-    .go()
-    .then((res) => {
-    const [item] = res.data;
-    const [unprocessed] = res.unprocessed;
-    (0, tsd_1.expectType)(item);
-    (0, tsd_1.expectType)(magnify(unprocessed));
-});
-entityWithoutSK
-    .get([{ attr1: "abc" }])
-    .go({ preserveBatchOrder: true })
-    .then((res) => {
-    const item = res.data[0];
-    const unprocessed = res.unprocessed[0];
-    (0, tsd_1.expectType)(item);
-    (0, tsd_1.expectType)(magnify(unprocessed));
-});
-entityWithoutSK
-    .get([{ attr1: "abc" }])
-    .go()
-    .then((res) => {
-    (0, tsd_1.expectAssignable)(res.data);
-    (0, tsd_1.expectAssignable)(res.unprocessed);
-});
-// Delete
-// Single
-entityWithSK.delete({ attr1: "adg", attr2: "ada" });
-entityWithoutSK.delete({ attr1: "adg" });
-(0, tsd_1.expectError)(entityWithSK.delete({}));
-(0, tsd_1.expectError)(entityWithSK.delete({ attr2: "abc" }));
-(0, tsd_1.expectError)(entityWithoutSK.delete({}));
-(0, tsd_1.expectError)(entityWithoutSK.delete({ attr1: "13", attr2: "abc" }));
-(0, tsd_1.expectAssignable)([{ attr1: "abc", attr2: "abd" }]);
-(0, tsd_1.expectAssignable)([{ attr1: "abc" }]);
-// Invalid Query
-(0, tsd_1.expectError)({ attr1: "sdggd" });
-(0, tsd_1.expectError)([{}]);
-(0, tsd_1.expectError)({ attr1: 1324, attr2: "adsga" });
-(0, tsd_1.expectError)({ attr1: 1324, attr2: "adsga" });
-let deleteSingleFinishers = getKeys(entityWithSK.delete({ attr1: "abc", attr2: "24" }));
-let deleteSingleFinishersWithoutSK = getKeys(entityWithoutSK.delete({ attr1: "abc" }));
-let deleteBatchFinishers = getKeys(entityWithSK.delete([{ attr1: "abc", attr2: "24" }]));
-let deleteBatchFinishersWithoutSK = getKeys(entityWithoutSK.delete([{ attr1: "abc" }]));
-(0, tsd_1.expectAssignable)(deleteSingleFinishers);
-(0, tsd_1.expectAssignable)(deleteSingleFinishersWithoutSK);
-(0, tsd_1.expectAssignable)(deleteBatchFinishers);
-(0, tsd_1.expectAssignable)(deleteBatchFinishersWithoutSK);
-entityWithSK.delete([{ attr1: "adg", attr2: "ada" }]).go({ concurrent: 24 });
-entityWithoutSK.delete([{ attr1: "adg" }]).go({ concurrent: 24 });
-entityWithSK
-    .delete([{ attr1: "adg", attr2: "ada" }])
-    .params({ concurrent: 24 });
-entityWithoutSK.delete([{ attr1: "adg" }]).params({ concurrent: 24 });
-let deleteSingleGo = entityWithSK.delete({ attr1: "adg", attr2: "ada" }).go;
-let deleteSingleGoWithoutSK = entityWithoutSK.delete({ attr1: "adg" }).go;
-let deleteSingleParams = entityWithSK.delete({
-    attr1: "adg",
-    attr2: "ada",
-}).params;
-let deleteSingleParamsWithoutSK = entityWithoutSK.delete({
-    attr1: "adg",
-}).params;
-let deleteBatchGo = entityWithSK.delete([{ attr1: "adg", attr2: "ada" }]).go;
-let deleteBatchGoWithoutSK = entityWithoutSK.delete([{ attr1: "adg" }]).go;
-let deleteBatchParams = entityWithSK.delete([
-    { attr1: "adg", attr2: "ada" },
-]).params;
-let deleteBatchParamsWithoutSK = entityWithoutSK.delete([
-    { attr1: "adg" },
-]).params;
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    response: "all_old",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    response: "all_old",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    response: "all_old",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    response: "all_old",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-});
-(0, tsd_1.expectError)({ concurrent: 10, unprocessed: "raw" });
-(0, tsd_1.expectError)({
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectNotAssignable)({ response: "updated_new" });
-(0, tsd_1.expectNotAssignable)({ response: "updated_new" });
-(0, tsd_1.expectError)({ concurrent: 10, unprocessed: "raw" });
-(0, tsd_1.expectError)({
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectNotAssignable)({ response: "updated_new" });
-(0, tsd_1.expectNotAssignable)({
-    response: "updated_new",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-});
-// Where
-entityWithSK.delete({ attr1: "asbc", attr2: "gdd" }).where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectAssignable)(AttributeName);
-    (0, tsd_1.expectAssignable)(opKeys);
-    return "";
-});
-entityWithoutSK.delete({ attr1: "asbc" }).where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectAssignable)(AttributeName);
-    (0, tsd_1.expectAssignable)(opKeys);
-    return "";
-});
-// Results
-(0, tsd_1.expectAssignable)(entityWithSK
-    .delete({ attr1: "abc", attr2: "def" })
-    .go({ response: "all_old" })
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithSK
-    .delete({ attr1: "abc", attr2: "def" })
-    .go({ response: "default" })
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithSK
-    .delete({ attr1: "abc", attr2: "def" })
-    .go()
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithSK
-    .delete({ attr1: "abc", attr2: "def" })
-    .go({ response: "none" })
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithoutSK
-    .delete({ attr1: "abc" })
-    .go({ response: "all_old" })
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithoutSK
-    .delete({ attr1: "abc" })
-    .go({ response: "none" })
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithoutSK
-    .delete({ attr1: "abc" })
-    .go({ response: "default" })
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithoutSK
-    .delete({ attr1: "abc" })
-    .go()
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithSK.delete({ attr1: "abc", attr2: "def" }).params());
-(0, tsd_1.expectAssignable)(entityWithoutSK.delete({ attr1: "abc" }).params());
-(0, tsd_1.expectAssignable)(entityWithoutSK
-    .delete([{ attr1: "abc" }])
-    .go()
-    .then((res) => res.unprocessed));
-// Put
-let putItemFull = {
-    attr1: "abnc",
-    attr2: "dsg",
-    attr3: "def",
-    attr4: "abc",
-    attr5: "dbs",
-    attr6: 13,
-    attr7: { abc: "2345" },
-    attr8: true,
-    attr9: 24,
-    attr10: true,
-};
-let putItemPartial = {
-    attr1: "abnc",
-    attr2: "dsg",
-    attr4: "abc",
-    attr8: true,
-};
-let putItemWithoutSK = {
-    attr1: "abnc",
-    attr4: "abc",
-    attr8: true,
-    attr3: "def",
-    attr5: "dbs",
-    attr6: 13,
-    attr9: 24,
-    attr7: { abc: "2345" },
-};
-let putItemWithoutPK = {
-    attr4: "abc",
-    attr2: "def",
-    attr8: true,
-    attr3: "def",
-    attr5: "dbs",
-    attr6: 13,
-    attr9: 24,
-    attr7: { abc: "2345" },
-};
-// Single
-entityWithSK.put(putItemFull);
-entityWithoutSK.put({
-    attr1: "abnc",
-    attr2: "dsg",
-    attr3: "def",
-    attr4: "def",
-    attr5: "dbs",
-    attr6: 13,
-    attr7: { abc: "2345" },
-    attr8: true,
-    attr9: 24,
-});
-entityWithSK.put({
-    attr1: "abnc",
-    attr2: "dsg",
-    attr3: "def",
-    attr4: "abc",
-    attr5: "dbs",
-    attr6: 13,
-    attr7: { abc: "2345" },
-    attr8: true,
-    attr9: undefined,
-    attr10: undefined,
-});
-entityWithoutSK.put(putItemPartial);
-(0, tsd_1.expectAssignable)([putItemFull]);
-(0, tsd_1.expectAssignable)([putItemFull]);
-(0, tsd_1.expectAssignable)([putItemPartial]);
-(0, tsd_1.expectAssignable)([putItemPartial]);
-// Invalid Query
-(0, tsd_1.expectError)([{}]);
-(0, tsd_1.expectError)([{}]);
-(0, tsd_1.expectError)([putItemWithoutSK]);
-(0, tsd_1.expectError)(putItemWithoutSK);
-(0, tsd_1.expectError)(putItemWithoutPK);
-(0, tsd_1.expectError)(putItemWithoutPK);
-// Assignable because attr1 has a default
-(0, tsd_1.expectAssignable)([putItemWithoutPK]);
-(0, tsd_1.expectError)([putItemWithoutPK]);
-(0, tsd_1.expectError)([
-    { attr1: "abnc", attr2: "dsg", attr4: "abc", attr8: "adef" },
-]);
-(0, tsd_1.expectError)([
-    { attr1: "abnc", attr2: "dsg", attr4: "abc", attr8: "adef" },
-]);
-let putSingleFinishers = getKeys(entityWithSK.put(putItemFull));
-let putSingleFinishersWithoutSK = getKeys(entityWithoutSK.put(putItemFull));
-let putBatchFinishers = getKeys(entityWithSK.put(putItemFull));
-let putBatchFinishersWithoutSK = getKeys(entityWithoutSK.put(putItemFull));
-let putSingleItem = entityWithSK.put(putItemFull);
-let putSingleItemWithoutSK = entityWithoutSK.put(putItemFull);
-let putBulkItem = entityWithSK.put([putItemFull]);
-let putBulkItemWithoutSK = entityWithoutSK.put([putItemFull]);
-(0, tsd_1.expectAssignable)(putSingleFinishers);
-(0, tsd_1.expectAssignable)(putSingleFinishersWithoutSK);
-(0, tsd_1.expectAssignable)(putBatchFinishers);
-(0, tsd_1.expectAssignable)(putBatchFinishersWithoutSK);
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    response: "all_old",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    response: "all_old",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    response: "all_old",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    response: "all_old",
-});
-(0, tsd_1.expectError)({ concurrent: 10, unprocessed: "raw" });
-(0, tsd_1.expectError)({
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectError)({ response: "updated_new" });
-(0, tsd_1.expectError)({ response: "updated_new" });
-(0, tsd_1.expectError)({ response: "updated_new" });
-(0, tsd_1.expectError)({ response: "updated_new" });
-(0, tsd_1.expectError)({ concurrent: 10, unprocessed: "raw" });
-(0, tsd_1.expectError)({
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectNotAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-    response: "all_old",
-});
-(0, tsd_1.expectNotAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-    response: "all_old",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-});
-(0, tsd_1.expectNotAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-    response: "all_old",
-});
-(0, tsd_1.expectNotAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    concurrent: 10,
-    unprocessed: "raw",
-    response: "all_old",
-});
-// Where
-entityWithSK.put(putItemFull).where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectAssignable)(AttributeName);
-    (0, tsd_1.expectAssignable)(opKeys);
-    return "";
-});
-entityWithoutSK.put(putItemFull).where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectAssignable)(AttributeName);
-    (0, tsd_1.expectAssignable)(opKeys);
-    return "";
-});
-// Results
-(0, tsd_1.expectAssignable)(entityWithSK
-    .put(putItemFull)
-    .go()
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithoutSK
-    .put(putItemFull)
-    .go()
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithSK.put(putItemFull).params());
-(0, tsd_1.expectAssignable)(entityWithoutSK.put(putItemFull).params());
-(0, tsd_1.expectAssignable)(entityWithSK
-    .put([putItemFull])
-    .go()
-    .then((res) => res.unprocessed));
-(0, tsd_1.expectAssignable)(entityWithoutSK
-    .put([putItemFull])
-    .go()
-    .then((res) => res.unprocessed));
-// Create
-let createItemFull = {
-    attr1: "abnc",
-    attr2: "dsg",
-    attr4: "abc",
-    attr8: true,
-    attr3: "def",
-    attr5: "dbs",
-    attr6: 13,
-    attr9: 24,
-    attr7: { abc: "2345" },
-};
-let createItemPartial = {
-    attr1: "abnc",
-    attr2: "dsg",
-    attr4: "abc",
-    attr8: true,
-};
-let createItemFullWithoutSK = {
-    attr4: "abc",
-    attr8: true,
-    attr3: "def",
-    attr5: "dbs",
-    attr6: 13,
-    attr9: 24,
-    attr7: { abc: "2345" },
-};
-let createItemFullWithoutPK = {
-    attr2: "dsg",
-    attr4: "abc",
-    attr8: true,
-    attr3: "def",
-    attr5: "dbs",
-    attr6: 13,
-    attr9: 24,
-    attr7: { abc: "2345" },
-};
-// Single
-entityWithSK.create(createItemFull);
-entityWithSK.create(createItemFullWithoutPK);
-entityWithoutSK.create(createItemFull);
-entityWithSK.create(createItemPartial);
-entityWithoutSK.create(createItemPartial);
-// batch not supported with create
-(0, tsd_1.expectError)([createItemFull]);
-(0, tsd_1.expectError)([createItemFull]);
-// batch not supported with create
-(0, tsd_1.expectError)([createItemPartial]);
-(0, tsd_1.expectError)([createItemPartial]);
-// Invalid Query
-(0, tsd_1.expectError)({});
-(0, tsd_1.expectError)({});
-(0, tsd_1.expectError)(createItemFullWithoutSK);
-// Assignable because attr1 has a default value
-(0, tsd_1.expectAssignable)(createItemFullWithoutPK);
-(0, tsd_1.expectError)(createItemFullWithoutPK);
-// Missing required properties
-(0, tsd_1.expectError)([
-    { attr1: "abnc", attr2: "dsg", attr4: "abc", attr8: "adef" },
-]);
-(0, tsd_1.expectError)([
-    { attr1: "abnc", attr2: "dsg", attr4: "abc", attr8: "adef" },
-]);
-let createSingleFinishers = getKeys(entityWithSK.create(putItemFull));
-let createSingleFinishersWithoutSK = getKeys(entityWithoutSK.create(putItemFull));
-let createItem = entityWithSK.put(createItemFull);
-let createItemWithoutSK = entityWithoutSK.put(createItemFull);
-(0, tsd_1.expectAssignable)(createSingleFinishers);
-(0, tsd_1.expectAssignable)(createSingleFinishersWithoutSK);
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-});
-(0, tsd_1.expectError)({ concurrent: 10, unprocessed: "raw" });
-(0, tsd_1.expectError)({ concurrent: 10, unprocessed: "raw" });
-(0, tsd_1.expectError)({ concurrent: 10, unprocessed: "raw" });
-(0, tsd_1.expectError)({
-    concurrent: 10,
-    unprocessed: "raw",
-});
-// Where
-entityWithSK.create(putItemFull).where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectAssignable)(AttributeName);
-    (0, tsd_1.expectAssignable)(opKeys);
-    return "";
-});
-entityWithoutSK.create(putItemFull).where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectAssignable)(AttributeName);
-    (0, tsd_1.expectAssignable)(opKeys);
-    return "";
-});
-// Results
-(0, tsd_1.expectAssignable)(entityWithSK
-    .create(putItemFull)
-    .go()
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithoutSK
-    .create(putItemFull)
-    .go()
-    .then((res) => res.data));
-(0, tsd_1.expectAssignable)(entityWithSK.create(putItemFull).params());
-(0, tsd_1.expectAssignable)(entityWithoutSK.create(putItemFull).params());
-// Update
-let setItemFull = {
-    attr4: "abc",
-    attr8: true,
-    attr3: "def",
-    attr5: "dbs",
-    attr6: 13,
-    attr9: 24,
-    attr7: { abc: "2345" },
-};
-let setFn = entityWithSK.update({ attr1: "abc", attr2: "def" }).set;
-let setFnWithoutSK = entityWithoutSK.update({ attr1: "abc" }).set;
-(0, tsd_1.expectAssignable)(setItemFull);
-(0, tsd_1.expectAssignable)(setItemFull);
-(0, tsd_1.expectAssignable)({});
-(0, tsd_1.expectAssignable)({});
-// Invalid Set
-(0, tsd_1.expectError)({ attr1: "ff" });
-(0, tsd_1.expectError)({ attr1: "ff" });
-(0, tsd_1.expectError)({ attr6: "1234" });
-(0, tsd_1.expectError)({ attr6: "1234" });
-let compositeFn = entityWithSK.update({ attr1: "abc", attr2: "def" }).composite;
-let compositeFnWithoutSK = entityWithoutSK.update({ attr1: "abc" }).composite;
-const compositeParameters = {};
-const compositeParametersWithoutSk = {};
-(0, tsd_1.expectType)(magnify(compositeParameters));
-(0, tsd_1.expectType)(magnify(compositeParametersWithoutSk));
-let updateItem = entityWithSK.update({ attr1: "abc", attr2: "def" }).set({});
-let updateItemWithoutSK = entityWithoutSK.update({ attr1: "abc" }).set({});
-let updateFinishers = getKeys(updateItem);
-let updateFinishersWithoutSK = getKeys(updateItemWithoutSK);
-(0, tsd_1.expectAssignable)(updateFinishers);
-(0, tsd_1.expectAssignable)(updateFinishersWithoutSK);
-let updateGo = updateItem.go;
-let updateGoWithoutSK = updateItemWithoutSK.go;
-let updateParams = updateItem.params;
-let updateParamsWithoutSK = updateItemWithoutSK.params;
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    response: "updated_new",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    response: "updated_new",
-});
-(0, tsd_1.expectAssignable)({
-    params: {},
-    table: "abc",
-    response: "updated_new",
-});
-(0, tsd_1.expectAssignable)({
-    params: {},
-    table: "abc",
-    response: "updated_new",
-});
-// Where
-updateItem.where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectAssignable)(AttributeName);
-    (0, tsd_1.expectAssignable)(opKeys);
-    return "";
-});
-updateItemWithoutSK.where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectAssignable)(AttributeName);
-    (0, tsd_1.expectAssignable)(opKeys);
-    return "";
-});
-// Patch
-let patchItemFull = {
-    attr4: "abc",
-    attr8: true,
-    attr3: "def",
-    attr5: "dbs",
-    attr6: 13,
-    attr9: 24,
-    attr7: { abc: "2345" },
-};
-let patchFn = entityWithSK.patch({ attr1: "abc", attr2: "def" }).set;
-let patchFnWithoutSK = entityWithoutSK.patch({ attr1: "abc" }).set;
-(0, tsd_1.expectAssignable)(patchItemFull);
-(0, tsd_1.expectAssignable)(patchItemFull);
-(0, tsd_1.expectAssignable)({});
-(0, tsd_1.expectAssignable)({});
-// Invalid Set
-(0, tsd_1.expectError)({ attr1: "ff" });
-(0, tsd_1.expectError)({ attr1: "ff" });
-(0, tsd_1.expectError)({ attr6: "1234" });
-(0, tsd_1.expectError)({ attr6: "1234" });
-let compositePatchFn = entityWithSK.update({
-    attr1: "abc",
-    attr2: "def",
-}).composite;
-let compositePatchFnWithoutSK = entityWithoutSK.update({
-    attr1: "abc",
-}).composite;
-const compositePatchParameters = {};
-const compositePatchParametersWithoutSk = {};
-(0, tsd_1.expectType)(magnify(compositePatchParameters));
-(0, tsd_1.expectType)(magnify(compositePatchParametersWithoutSk));
-let patchItem = entityWithSK.patch({ attr1: "abc", attr2: "def" }).set({});
-let patchItemWithoutSK = entityWithoutSK.patch({ attr1: "abc" }).set({});
-let patchFinishers = getKeys(patchItem);
-let patchFinishersWithoutSK = getKeys(patchItemWithoutSK);
-(0, tsd_1.expectAssignable)(patchFinishers);
-(0, tsd_1.expectAssignable)(patchFinishersWithoutSK);
-let patchGo = patchItem.go;
-let patchGoWithoutSK = patchItemWithoutSK.go;
-let patchParams = patchItem.params;
-let patchParamsWithoutSK = patchItemWithoutSK.params;
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    response: "updated_new",
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    response: "updated_new",
-});
-(0, tsd_1.expectAssignable)({
-    params: {},
-    table: "abc",
-    response: "updated_new",
-});
-(0, tsd_1.expectAssignable)({
-    params: {},
-    table: "abc",
-    response: "updated_new",
-});
-// Where
-patchItem.where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectAssignable)(AttributeName);
-    (0, tsd_1.expectAssignable)(opKeys);
-    return "";
-});
-patchItemWithoutSK.where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectAssignable)(AttributeName);
-    (0, tsd_1.expectAssignable)(opKeys);
-    return "";
-});
-// Find
-// Query
-let findFn = entityWithSK.find;
-let findFnWithoutSK = entityWithoutSK.find;
-(0, tsd_1.expectAssignable)(AttributeName);
-(0, tsd_1.expectAssignable)(AttributeName);
-(0, tsd_1.expectAssignable)({ attr6: 13 });
-(0, tsd_1.expectAssignable)({ attr6: 13 });
-//  Invalid query
-(0, tsd_1.expectError)({ attr6: "ff" });
-(0, tsd_1.expectError)({ attr6: "ff" });
-(0, tsd_1.expectError)({ noexist: "ff" });
-(0, tsd_1.expectError)({ noexist: "ff" });
-// Where
-findFn({}).where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectAssignable)(AttributeName);
-    (0, tsd_1.expectAssignable)(opKeys);
-    return "";
-});
-findFnWithoutSK({}).where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectAssignable)(AttributeName);
-    (0, tsd_1.expectAssignable)(opKeys);
-    return "";
-});
-let findFinishers = entityWithSK.find({});
-let findFinishersWithoutSK = entityWithoutSK.find({});
-let matchFinishers = entityWithSK.match({});
-let matchFinishersWithoutSK = entityWithoutSK.match({});
-let findFinisherKeys = getKeys(findFinishers);
-let findFinisherKeysWithoutSK = getKeys(findFinishersWithoutSK);
-let matchFinisherKeys = getKeys(matchFinishers);
-let matchFinisherKeysWithoutSK = getKeys(matchFinishersWithoutSK);
-(0, tsd_1.expectAssignable)(findFinisherKeys);
-(0, tsd_1.expectAssignable)(findFinisherKeysWithoutSK);
-(0, tsd_1.expectAssignable)(matchFinisherKeys);
-(0, tsd_1.expectAssignable)(matchFinisherKeysWithoutSK);
-let findGo = findFinishers.go;
-let findGoWithoutSK = findFinishersWithoutSK.go;
-let matchGo = matchFinishers.go;
-let matchGoWithoutSK = matchFinishersWithoutSK.go;
-let findParams = findFinishers.params;
-let findParamsWithoutSK = findFinishersWithoutSK.params;
-let matchParams = matchFinishers.params;
-let matchParamsWithoutSK = matchFinishersWithoutSK.params;
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    pages: 123,
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    pages: 123,
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    pages: 123,
-});
-(0, tsd_1.expectAssignable)({
-    data: 'includeKeys',
-    originalErr: true,
-    params: {},
-    table: "abc",
-    pages: 123,
-});
-(0, tsd_1.expectAssignable)({ params: {}, table: "abc" });
-(0, tsd_1.expectAssignable)({ params: {}, table: "abc" });
-(0, tsd_1.expectAssignable)({ params: {}, table: "abc" });
-(0, tsd_1.expectAssignable)({ params: {}, table: "abc" });
-let accessPatternNames = getKeys(entityWithSK.query);
-let accessPatternNamesWithoutSK = getKeys(entityWithoutSK.query);
-(0, tsd_1.expectType)(accessPatternNames);
-(0, tsd_1.expectType)(accessPatternNamesWithoutSK);
-let myIndexBegins = entityWithSK.query.myIndex({ attr1: "abc" }).begins;
-// Begins does not exist on Find because the user has tossed out knowledge of order/indexes
-(0, tsd_1.expectError)(entityWithoutSK.query.myIndex({ attr1: "abc" }).begins);
-(0, tsd_1.expectAssignable)({ attr1: "abd" });
-(0, tsd_1.expectAssignable)({ attr1: "abd" });
-(0, tsd_1.expectAssignable)({ attr1: "abd", attr2: "def" });
-(0, tsd_1.expectAssignable)({ attr1: "abd" });
-(0, tsd_1.expectAssignable)({});
-(0, tsd_1.expectAssignable)({ attr2: "abc" });
-// attr1 not supplied
-(0, tsd_1.expectError)({ attr2: "abc" });
-(0, tsd_1.expectError)({ attr2: "abc" });
-// attr2 is a strin, not number
-(0, tsd_1.expectError)({ attr1: "abd", attr2: 133 });
-(0, tsd_1.expectError)({ attr1: 243 });
-// attr3 is not a pk or sk
-(0, tsd_1.expectError)({
-    attr1: "abd",
-    attr2: "def",
-    attr3: "should_not_work",
-});
-(0, tsd_1.expectError)({
-    attr1: "abd",
-    attr2: "def",
-    attr3: "should_not_work",
-});
-// attr1 was already used in the query method
-(0, tsd_1.expectError)({ attr1: "abd" });
-// attr2 is a string not number (this tests the 'remaining' composite attributes which should also enforce type)
-(0, tsd_1.expectError)({ attr2: 1243 });
-// require at least PK
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({}));
-(0, tsd_1.expectError)(entityWithoutSK.query.myIndex({}));
-// attr6 should be number
-(0, tsd_1.expectError)(entityWithSK.query.myIndex2({ attr6: "45" }));
-(0, tsd_1.expectError)(entityWithoutSK.query.myIndex2({ attr6: "45" }));
-entityWithSK.query
-    .myIndex({ attr1: "abc", attr2: "def" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithSK.query
-    .myIndex({ attr1: "abc" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithSK.query
-    .myIndex2({ attr6: 45, attr9: 454, attr4: "abc", attr5: "def" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithSK.query
-    .myIndex2({ attr6: 45, attr9: 24 })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithSK.query
-    .myIndex3({ attr5: "dgdagad" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithoutSK.query
-    .myIndex({ attr1: "abc" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithoutSK.query
-    .myIndex2({ attr6: 53, attr9: 35 })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithoutSK.query
-    .myIndex3({ attr5: "dgdagad" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-// Query Operations
-entityWithSK.query
-    .myIndex({ attr1: "abc" })
-    .begins({ attr2: "asf" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithSK.query
-    .myIndex2({ attr6: 45, attr9: 34, attr4: "abc" })
-    .begins({ attr5: "db" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithSK.query
-    .myIndex3({ attr5: "dgdagad" })
-    .between({ attr4: "abc", attr9: 3, attr3: "def" }, { attr4: "abc", attr9: 4, attr3: "def" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithSK.query
-    .myIndex({ attr1: "abc" })
-    .gte({ attr2: "asf" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithSK.query
-    .myIndex2({ attr6: 45, attr9: 33, attr4: "abc" })
-    .gt({ attr5: "abd" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithSK.query
-    .myIndex3({ attr5: "dgdagad" })
-    .lte({ attr4: "abc", attr9: 3 })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithSK.query
-    .myIndex3({ attr5: "dgdagad" })
-    .lt({ attr4: "abc", attr9: 3 })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4));
-entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-        ${name(attr6)} = ${value(attr6, 12)}
-        AND ${exists(attr6)}
-        AND ${notExists(attr6)}
-        AND ${begins(attr6, 35)}
-        AND ${between(attr6, 1, 10)}
-        AND ${contains(attr6, 14)}
-        AND ${eq(attr6, 14)}
-        AND ${gt(attr6, 14)}
-        AND ${gte(attr6, 14)}
-        AND ${lt(attr6, 14)}
-        AND ${lte(attr6, 14)}
-        AND ${notContains(attr6, 14)}
-      `);
-// Query Operations (Except with Type Errors)
-// This one ensures that an SK value in the index method still is type checked
-(0, tsd_1.expectError)(entityWithSK.query
-    .myIndex({ attr1: "452", attr2: 245 })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-(0, tsd_1.expectError)(entityWithSK.query
-    .myIndex2({ attr6: "45" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-(0, tsd_1.expectError)(entityWithSK.query
-    .myIndex3({ attr5: 426 })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-(0, tsd_1.expectError)(entityWithoutSK.query
-    .myIndex({ attr1: 246 })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-(0, tsd_1.expectError)(entityWithoutSK.query
-    .myIndex2({ attr6: 24, attr9: "1" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-(0, tsd_1.expectError)(entityWithoutSK.query
-    .myIndex3({ attr5: 346 })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-// Query Operations
-(0, tsd_1.expectError)(entityWithSK.query
-    .myIndex({ attr1: "abc" })
-    .begins({ attr2: 42 })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-(0, tsd_1.expectError)(entityWithSK.query
-    .myIndex2({ attr6: 45, attr4: "abc" })
-    .begins({ attr5: 462 })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-(0, tsd_1.expectError)(entityWithSK.query
-    .myIndex3({ attr5: "dgdagad" })
-    .between({ attr4: "abc", attr9: "3", attr3: "def" }, { attr4: "abc", attr9: "4", attr3: "def" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-(0, tsd_1.expectError)(entityWithSK.query
-    .myIndex({ attr1: "abc" })
-    .gte({ attr2: 462 })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-(0, tsd_1.expectError)(entityWithSK.query
-    .myIndex2({ attr6: 45, attr4: "abc" })
-    .gt({ attr5: 246 })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-(0, tsd_1.expectError)(entityWithSK.query
-    .myIndex3({ attr5: "dgdagad" })
-    .lte({ attr4: "abc", attr9: "3" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-(0, tsd_1.expectError)(entityWithSK.query
-    .myIndex3({ attr5: "dgdagad" })
-    .lt({ attr4: "abc", attr9: "3" })
-    .go({ params: {} })
-    .then((a) => a.data.map((val) => val.attr4)));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${name(attr6)} = ${value()}
-          `));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${exists()}
-        `));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${notExists()}
-        `));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${begins(attr6, "35")}
-        `));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${between(attr6, "1", 10)}
-        `));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${between(attr6, 1, "10")}
-        `));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${contains(attr6, "14")}
-        `));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${eq(attr6, "14")}
-        `));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${gt(attr6, "14")}
-        `));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${gte(attr6, "14")}
-        `));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${lt(attr6, "14")}
-        `));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${lte(attr6, "14")}
-        `));
-(0, tsd_1.expectError)(entityWithSK.query.myIndex({ attr1: "abc", attr2: "db" }).where(({ attr6 }, { value, name, exists, begins, between, contains, eq, gt, gte, lt, lte, notContains, notExists, }) => `
-            ${notContains(attr6, "14")}
-        `));
-// Invalid cases
-(0, tsd_1.expectError)(() => new _1.Service({ abc: "123" }));
-// Service with no Entities
-// let nullCaseService = new Service({});
-// type NullCollections = typeof nullCaseService.collections;
-// type NullEntities = typeof nullCaseService.collections;
-// expectType<NullCollections>(magnify({}));
-// expectType<NullEntities>(magnify({}));
-// Service with no Collections
-// let serviceNoCollections = new Service({standAloneEntity});
-// type noEntityCollections = typeof serviceNoCollections.collections;
-// expectType<noEntityCollections>({});
-// Service no shared entity collections
-let serviceNoShared = new _1.Service({
-    entityWithoutSK,
-    standAloneEntity,
-    normalEntity1,
-});
-let expectNoSharedCollections = "";
-(0, tsd_1.expectType)(expectNoSharedCollections);
-const noSharedCollectionParameter1 = {};
-(0, tsd_1.expectType)(noSharedCollectionParameter1);
-(0, tsd_1.expectError)({});
-(0, tsd_1.expectError)({ attr5: 123 });
-(0, tsd_1.expectError)({ attr1: "123" });
-const noSharedCollectionParameter2 = {};
-(0, tsd_1.expectType)(noSharedCollectionParameter2);
-(0, tsd_1.expectError)({});
-(0, tsd_1.expectError)({ prop2: "abc" });
-(0, tsd_1.expectError)({ prop1: "abc" });
-(0, tsd_1.expectError)({ prop1: 35 });
-(0, tsd_1.expectError)({ prop2: 35 });
-(0, tsd_1.expectError)({ prop3: "35" });
-// Service with complex collections
-let complexService = new _1.Service({
-    entityWithoutSK,
-    entityWithSK,
-    standAloneEntity,
-    normalEntity1,
-    normalEntity2,
-});
-let expectSharedCollections = "";
-(0, tsd_1.expectType)(expectSharedCollections);
-// success
-complexService.collections.mycollection({ attr5: "abc" });
-// failure - no collection composite attributes
-(0, tsd_1.expectError)({});
-// failure - incorrect entity composite attribute types
-(0, tsd_1.expectError)({ attr5: 123 });
-// failure - incorrect entity composite attribute properties
-(0, tsd_1.expectError)({ attr1: "123" });
-// success
-complexService.collections.normalcollection({ prop2: "abc", prop1: "def" });
-// failure - no collection composite attributes
-(0, tsd_1.expectError)({});
-// failure - incomplete composite attributes
-(0, tsd_1.expectError)({ prop2: "abc" });
-// failure - incomplete composite attributes
-(0, tsd_1.expectError)({ prop1: "abc" });
-// failure - incorrect entity composite attribute types
-(0, tsd_1.expectError)({ prop1: 35 });
-// failure - incorrect entity composite attribute types
-(0, tsd_1.expectError)({ prop2: 35 });
-// failure - incorrect entity composite attribute properties
-(0, tsd_1.expectError)({ prop3: "35" });
-let chainMethods = complexService.collections.normalcollection({
-    prop2: "abc",
-    prop1: "def",
-});
-let expectedAfterQueryChainMethods = "";
-(0, tsd_1.expectType)(expectedAfterQueryChainMethods);
-(0, tsd_1.expectAssignable)({
-    table: "df",
-    params: {},
-    originalErr: true,
-    data: 'includeKeys',
-    pages: 123,
-});
-complexService.collections
-    .normalcollection({ prop2: "abc", prop1: "def" })
-    .go()
-    .then((res) => {
-    let expectedEntities = "";
-    (0, tsd_1.expectType)(expectedEntities);
-    res.data.normalEntity1.map((item) => {
-        (0, tsd_1.expectError)(item.attr1);
-        (0, tsd_1.expectError)(item.attr2);
-        (0, tsd_1.expectError)(item.attr3);
-        (0, tsd_1.expectError)(item.attr4);
-        (0, tsd_1.expectError)(item.attr5);
-        (0, tsd_1.expectError)(item.attr6);
-        (0, tsd_1.expectError)(item.attr7);
-        (0, tsd_1.expectError)(item.attr8);
-        (0, tsd_1.expectError)(item.attr9);
-        (0, tsd_1.expectError)(item.attr10);
-        (0, tsd_1.expectType)(item.prop1);
-        (0, tsd_1.expectType)(item.prop2);
-        (0, tsd_1.expectType)(item.prop3);
-        (0, tsd_1.expectType)(item.prop4);
-        (0, tsd_1.expectType)(item.prop10);
-        let itemKeys = "";
-        (0, tsd_1.expectType)(itemKeys);
-    });
-    res.data.normalEntity2.map((item) => {
-        (0, tsd_1.expectType)(item.prop1);
-        (0, tsd_1.expectType)(item.prop2);
-        (0, tsd_1.expectType)(item.prop3);
-        (0, tsd_1.expectType)(item.prop5);
-        (0, tsd_1.expectType)(item.attr9);
-        (0, tsd_1.expectType)(item.attr6);
-        (0, tsd_1.expectNotAssignable)(item);
-        (0, tsd_1.expectNotAssignable)(item);
-        (0, tsd_1.expectNotAssignable)(item);
-        (0, tsd_1.expectNotAssignable)(item);
-        (0, tsd_1.expectNotAssignable)(item);
-        (0, tsd_1.expectNotAssignable)(item);
-        (0, tsd_1.expectNotAssignable)(item);
-        (0, tsd_1.expectNotAssignable)(item);
-        (0, tsd_1.expectNotAssignable)(item);
-        (0, tsd_1.expectNotAssignable)(item);
-        (0, tsd_1.expectNotAssignable)(item);
-        let itemKeys = "";
-        (0, tsd_1.expectType)(itemKeys);
-    });
-});
-complexService.collections
-    .mycollection({ attr5: "sgad" })
-    .go()
-    .then((res) => {
-    let expectedEntities = "";
-    (0, tsd_1.expectType)(expectedEntities);
-    res.data.entityWithSK.map((item) => {
-        (0, tsd_1.expectType)(item.attr1);
-        (0, tsd_1.expectType)(item.attr2);
-        (0, tsd_1.expectType)(item.attr3);
-        (0, tsd_1.expectType)(item.attr4);
-        (0, tsd_1.expectType)(item.attr5);
-        (0, tsd_1.expectType)(item.attr6);
-        (0, tsd_1.expectType)(item.attr7);
-        (0, tsd_1.expectType)(item.attr8);
-        (0, tsd_1.expectType)(item.attr9);
-        (0, tsd_1.expectType)(item.attr10);
-        // .go response related entities correct items
-        let itemKeys = "";
-        (0, tsd_1.expectType)(itemKeys);
-    });
-    res.data.entityWithoutSK.map((item) => {
-        item.attr2;
-        (0, tsd_1.expectType)(item.attr1);
-        (0, tsd_1.expectType)(item.attr2);
-        (0, tsd_1.expectType)(item.attr3);
-        (0, tsd_1.expectType)(item.attr4);
-        (0, tsd_1.expectType)(item.attr5);
-        (0, tsd_1.expectType)(item.attr6);
-        (0, tsd_1.expectType)(item.attr7);
-        (0, tsd_1.expectType)(item.attr8);
-        (0, tsd_1.expectType)(item.attr9);
-        // .go response related entities correct items
-        let itemKeys = "";
-        (0, tsd_1.expectType)(itemKeys);
-    });
-});
-let serviceWhere = complexService.collections
-    .mycollection1({ attr6: 13, attr9: 54 })
-    .where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectType)(opKeys);
-    op.eq(attr.attr9, 455);
-    op.eq(attr.prop5, 455);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    return "";
-})
-    .go()
-    .then((res) => {
-    res.data.normalEntity2.map((item) => {
-        let keys = "";
-        (0, tsd_1.expectType)(keys);
-        (0, tsd_1.expectType)(item.prop1);
-        (0, tsd_1.expectType)(item.prop2);
-        (0, tsd_1.expectType)(item.prop3);
-        (0, tsd_1.expectType)(item.prop5);
-        (0, tsd_1.expectType)(item.attr6);
-        (0, tsd_1.expectType)(item.attr9);
-    });
-    res.data.entityWithSK.map((item) => {
-        let keys = "";
-        (0, tsd_1.expectType)(keys);
-        (0, tsd_1.expectType)(item.attr1);
-        (0, tsd_1.expectType)(item.attr2);
-        (0, tsd_1.expectType)(item.attr3);
-        (0, tsd_1.expectType)(item.attr4);
-        (0, tsd_1.expectType)(item.attr5);
-        (0, tsd_1.expectType)(item.attr6);
-        (0, tsd_1.expectType)(item.attr7);
-        (0, tsd_1.expectType)(item.attr8);
-        (0, tsd_1.expectType)(item.attr9);
-        (0, tsd_1.expectType)(item.attr10);
-    });
-    res.data.entityWithoutSK.map((item) => {
-        let keys = "";
-        (0, tsd_1.expectType)(keys);
-        (0, tsd_1.expectType)(item.attr1);
-        (0, tsd_1.expectType)(item.attr2);
-        (0, tsd_1.expectType)(item.attr3);
-        (0, tsd_1.expectType)(item.attr4);
-        (0, tsd_1.expectType)(item.attr5);
-        (0, tsd_1.expectType)(item.attr6);
-        (0, tsd_1.expectType)(item.attr7);
-        (0, tsd_1.expectType)(item.attr8);
-        (0, tsd_1.expectType)(item.attr9);
-    });
-});
-complexService.collections
-    .normalcollection({ prop1: "abc", prop2: "def" })
-    .where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectType)(opKeys);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    return op.eq(attr.prop1, "db");
-})
-    .go()
-    .then((res) => {
-    res.data.normalEntity1.map((item) => {
-        let keys = "";
-        (0, tsd_1.expectType)(keys);
-        (0, tsd_1.expectType)(item.prop1);
-        (0, tsd_1.expectType)(item.prop2);
-        (0, tsd_1.expectType)(item.prop3);
-        (0, tsd_1.expectType)(item.prop4);
-        (0, tsd_1.expectType)(item.prop10);
-    });
-    res.data.normalEntity2.map((item) => {
-        let keys = "";
-        (0, tsd_1.expectType)(keys);
-        (0, tsd_1.expectType)(item.prop1);
-        (0, tsd_1.expectType)(item.prop2);
-        (0, tsd_1.expectType)(item.prop3);
-        (0, tsd_1.expectType)(item.prop5);
-        (0, tsd_1.expectType)(item.attr6);
-        (0, tsd_1.expectType)(item.attr9);
-    });
-});
-complexService.collections
-    .mycollection2({ attr1: "abc" })
-    .where((attr, op) => {
-    let opKeys = getKeys(op);
-    (0, tsd_1.expectType)(opKeys);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    (0, tsd_1.expectNotAssignable)(attr);
-    return op.eq(attr.attr9, 768);
-})
-    .go()
-    .then((res) => {
-    res.data.entityWithSK.map((item) => {
-        let keys = "";
-        (0, tsd_1.expectType)(keys);
-        (0, tsd_1.expectType)(item.attr1);
-        (0, tsd_1.expectType)(item.attr2);
-        (0, tsd_1.expectType)(item.attr3);
-        (0, tsd_1.expectType)(item.attr4);
-        (0, tsd_1.expectType)(item.attr5);
-        (0, tsd_1.expectType)(item.attr6);
-        (0, tsd_1.expectType)(item.attr7);
-        (0, tsd_1.expectType)(item.attr8);
-        (0, tsd_1.expectType)(item.attr9);
-        (0, tsd_1.expectType)(item.attr10);
-    });
-});
-let entityWithHiddenAttributes1 = new _1.Entity({
-    model: {
-        entity: "e1",
-        service: "s1",
-        version: "1",
-    },
-    attributes: {
-        prop1: {
-            type: "string",
-        },
-        prop2: {
-            type: "string",
-        },
-        prop3: {
-            type: "string",
-            hidden: true,
-        },
-    },
-    indexes: {
-        record: {
-            collection: "collection1",
-            pk: {
-                field: "pk",
-                composite: ["prop1"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["prop2"],
-            },
-        },
-    },
-});
-let entityWithHiddenAttributes2 = new _1.Entity({
-    model: {
-        entity: "e2",
-        service: "s1",
-        version: "1",
-    },
-    attributes: {
-        prop1: {
-            type: "string",
-        },
-        prop2: {
-            type: "string",
-        },
-        prop4: {
-            type: "string",
-            hidden: true,
-        },
-        prop5: {
-            type: "string",
-        },
-    },
-    indexes: {
-        record: {
-            collection: "collection1",
-            pk: {
-                field: "pk",
-                composite: ["prop1"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["prop2"],
-            },
-        },
-    },
-});
-const serviceWithHiddenAttributes = new _1.Service({
-    e1: entityWithHiddenAttributes1,
-    e2: entityWithHiddenAttributes2,
-});
-let entity1WithHiddenAttributeKey = "";
-let entity2WithHiddenAttributeKey = "";
-entityWithHiddenAttributes1
-    .get({ prop1: "abc", prop2: "def" })
-    .where((attr, op) => {
-    (0, tsd_1.expectAssignable)(attr);
-    return op.eq(attr.prop3, "abc");
-})
-    .go()
-    .then((res) => {
-    if (res.data !== null) {
-        (0, tsd_1.expectType)(entity1WithHiddenAttributeKey);
-        (0, tsd_1.expectType)(res.data);
-    }
-});
-entityWithHiddenAttributes1.query
-    .record({ prop1: "abc" })
-    .where((attr, op) => {
-    (0, tsd_1.expectAssignable)(attr);
-    return op.eq(attr.prop3, "abc");
-})
-    .go()
-    .then((res) => {
-    return res.data.map((value) => {
-        (0, tsd_1.expectType)(entity1WithHiddenAttributeKey);
-        (0, tsd_1.expectType)(value);
-    });
-});
-serviceWithHiddenAttributes.collections
-    .collection1({ prop1: "abc" })
-    .where((attr, op) => {
-    (0, tsd_1.expectAssignable)(attr);
-    (0, tsd_1.expectAssignable)(attr);
-    return `${op.eq(attr.prop3, "abc")} AND ${op.eq(attr.prop4, "def")}`;
-})
-    .go()
-    .then((res) => {
-    res.data.e1.map((value) => {
-        (0, tsd_1.expectType)(entity1WithHiddenAttributeKey);
-        (0, tsd_1.expectType)(value);
-    });
-    res.data.e2.map((value) => {
-        (0, tsd_1.expectType)(entity2WithHiddenAttributeKey);
-        (0, tsd_1.expectType)(value.prop1);
-        (0, tsd_1.expectType)(value.prop2);
-        (0, tsd_1.expectType)(value.prop5);
-    });
-});
-let entityWithRequiredAttribute = new _1.Entity({
-    model: {
-        entity: "e1",
-        service: "s1",
-        version: "1",
-    },
-    attributes: {
-        prop1: {
-            type: "string",
-        },
-        prop2: {
-            type: "string",
-        },
-        prop3: {
-            type: "string",
-            required: true,
-        },
-        prop4: {
-            type: "number",
-            required: true,
-        },
-        prop5: {
-            type: "any",
-            required: true,
-        },
-        prop6: {
-            type: "map",
-            properties: {
-                nested1: {
-                    type: "string",
-                    required: true,
-                },
-            },
-            required: true,
-        },
-        prop7: {
-            type: "list",
-            items: {
-                type: "string",
-                required: true,
-            },
-            required: true,
-        },
-        prop8: {
-            type: "string",
-            required: true,
-            default: "abc",
-        },
-        prop9: {
-            type: "map",
-            properties: {
-                nested1: {
-                    type: "string",
-                    required: true,
-                    default: () => "abc",
-                },
-                nested2: {
-                    type: "string",
-                    required: true,
-                    default: "abc",
-                },
-            },
-            default: {},
-            required: true,
-        },
-        prop10: {
-            type: "list",
-            items: {
-                type: "string",
-            },
-            required: true,
-            default: [],
-        },
-    },
-    indexes: {
-        record: {
-            collection: "collection1",
-            pk: {
-                field: "pk",
-                composite: ["prop1"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["prop2"],
-            },
-        },
-    },
-});
-// required attributes, as object and array, without required (but defaulted attributes)
-entityWithRequiredAttribute.put({
-    prop1: "abc",
-    prop2: "def",
-    prop3: "ghi",
-    prop4: 123,
-    prop5: { anyVal: ["anyItem"] },
-    prop6: {
-        nested1: "abc",
-    },
-    prop7: [],
-});
-// required attributes, as object and array, without required (but defaulted attributes)
-entityWithRequiredAttribute.put([
-    {
-        prop1: "abc",
-        prop2: "def",
-        prop3: "ghi",
-        prop4: 123,
-        prop5: { anyVal: ["anyItem"] },
-        prop6: {
-            nested1: "abc",
-        },
-        prop7: [],
-    },
-]);
-// required attributes, as object and array, without required (but defaulted attributes)
-entityWithRequiredAttribute.create({
-    prop1: "abc",
-    prop2: "def",
-    prop3: "ghi",
-    prop4: 123,
-    prop5: { anyVal: ["anyItem"] },
-    prop6: {
-        nested1: "abc",
-    },
-    prop7: [],
-});
-// create doesnt allow for bulk
-(0, tsd_1.expectError)(() => {
-    entityWithRequiredAttribute.create([
-        {
-            prop1: "abc",
-            prop2: "def",
-            prop3: "ghi",
-            prop4: 123,
-            prop5: { anyVal: ["anyItem"] },
-            prop6: {
-                nested1: "abc",
-            },
-            prop7: [],
-        },
-    ]);
-});
-// missing `nested1` on `prop6`
-(0, tsd_1.expectError)(() => {
-    entityWithRequiredAttribute.put({
-        prop1: "abc",
-        prop2: "def",
-        prop3: "ghi",
-        prop4: 123,
-        prop5: { anyVal: ["anyItem"] },
-        prop6: {},
-        prop7: [],
-    });
-});
-// missing `nested1` on `prop6`
-(0, tsd_1.expectError)(() => {
-    entityWithRequiredAttribute.put([
-        {
-            prop1: "abc",
-            prop2: "def",
-            prop3: "ghi",
-            prop4: 123,
-            prop5: { anyVal: ["anyItem"] },
-            prop6: {},
-            prop7: [],
-        },
-    ]);
-});
-// missing `nested1` on `prop6`
-(0, tsd_1.expectError)(() => {
-    entityWithRequiredAttribute.create({
-        prop1: "abc",
-        prop2: "def",
-        prop3: "ghi",
-        prop4: 123,
-        prop5: { anyVal: ["anyItem"] },
-        prop6: {},
-        prop7: [],
-    });
-});
-// no removing required attributes
-(0, tsd_1.expectError)(() => {
-    entityWithRequiredAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .remove(["prop3"]);
-});
-// no removing required attributes
-(0, tsd_1.expectError)(() => {
-    entityWithRequiredAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .remove(["prop5"]);
-});
-// no removing required attributes
-(0, tsd_1.expectError)(() => {
-    entityWithRequiredAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .remove(["prop6"]);
-});
-// no removing required attributes
-(0, tsd_1.expectError)(() => {
-    entityWithRequiredAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .remove(["prop7"]);
-});
-let entityWithReadOnlyAttribute = new _1.Entity({
-    model: {
-        entity: "e1",
-        service: "s1",
-        version: "1",
-    },
-    attributes: {
-        prop1: {
-            type: "string",
-        },
-        prop2: {
-            type: "string",
-        },
-        prop3: {
-            type: "string",
-            readOnly: true,
-        },
-        prop4: {
-            type: "string",
-        },
-        prop5: {
-            type: "number",
-        },
-        prop6: {
-            type: "any",
-        },
-        prop7: {
-            type: "string",
-        },
-        prop8: {
-            type: ["abc", "def"],
-        },
-        prop9: {
-            type: "number",
-            readOnly: true,
-        },
-        prop10: {
-            type: "any",
-            readOnly: true,
-        },
-        prop11: {
-            type: "list",
-            items: {
-                type: "string",
-            },
-        },
-    },
-    indexes: {
-        record: {
-            collection: "collection1",
-            pk: {
-                field: "pk",
-                composite: ["prop1"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["prop2"],
-            },
-        },
-    },
-});
-entityWithReadOnlyAttribute
-    .put({ prop1: "abc", prop2: "def", prop3: "ghi" })
-    .params();
-entityWithReadOnlyAttribute
-    .create({ prop1: "abc", prop2: "def", prop3: "ghi" })
-    .params();
-// readonly
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .set({ prop3: "abc" })
-        .params();
-});
-// readonly
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .add({ prop9: 13 })
-        .params();
-});
-// readonly
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .subtract({ prop9: 13 })
-        .params();
-});
-// readonly
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .delete({ prop10: "13" })
-        .params();
-});
-// readonly
-// TODO: FIX ME
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .append({ prop10: ["abc"] })
-        .params();
-});
-// bad type - not number
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .add({ prop7: 13 })
-        .params();
-});
-// bad type - not number
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .subtract({ prop7: 13 })
-        .params();
-});
-// bad type - not string
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        // prop7 is string not number
-        .data(({ prop7 }, { set }) => set(prop7, 5))
-        .params();
-});
-// bad type - incorrect enum
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        // prop8 is enum with values ["abc", "def"]
-        .data(({ prop8 }, { set }) => set(prop8, "ghi"))
-        .params();
-});
-// bad type - not number
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .data(({ prop7 }, { subtract }) => subtract(prop7, 5))
-        .params();
-});
-// bad type - not number
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .data(({ prop7 }, { add }) => add(prop7, 5))
-        .params();
-});
-// bad type - not any
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .data(({ prop7 }, { del }) => del(prop7, 5))
-        .params();
-});
-// bad type - not any
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .data(({ prop7 }, op) => op.delete(prop7, 5))
-        .params();
-});
-// bad type - not any
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .delete({ prop7: "13", prop5: 24 })
-        .params();
-});
-// bad type - not any
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .delete({ prop5: 24 })
-        .params();
-});
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .append({ prop7: "13", prop5: 24 })
-        .params();
-});
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .append({ prop5: 24 })
-        .params();
-});
-// readonly
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .remove(["prop3"])
-        .params();
-});
-// readonly
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .data(({ prop3 }, { remove }) => {
-        remove(prop3);
-    })
-        .params();
-});
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .update({ prop1: "abc", prop2: "def" })
-        .data(({ prop5 }, { append }) => {
-        append(prop5, 25);
-    })
-        .params();
-});
-// patch
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .patch({ prop1: "abc", prop2: "def" })
-        .set({ prop3: "abc" })
-        .params();
-});
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .patch({ prop1: "abc", prop2: "def" })
-        .add({ prop7: 13 })
-        .params();
-});
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .patch({ prop1: "abc", prop2: "def" })
-        .subtract({ prop7: 13 })
-        .params();
-});
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .patch({ prop1: "abc", prop2: "def" })
-        .delete({ prop7: "13", prop5: 24 })
-        .params();
-});
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .patch({ prop1: "abc", prop2: "def" })
-        .delete({ prop5: 24 })
-        .params();
-});
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .patch({ prop1: "abc", prop2: "def" })
-        .append({ prop7: "13", prop5: 24 })
-        .params();
-});
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .patch({ prop1: "abc", prop2: "def" })
-        .append({ prop5: 24 })
-        .params();
-});
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .patch({ prop1: "abc", prop2: "def" })
-        .remove(["prop3"])
-        .params();
-});
-(0, tsd_1.expectError)(() => {
-    entityWithReadOnlyAttribute
-        .patch({ prop1: "abc", prop2: "def" })
-        .remove(["prop3"])
-        .params();
-});
-let setItemValue = {};
-entityWithReadOnlyAttribute
-    .update({ prop1: "abc", prop2: "def" })
-    .set(setItemValue)
-    .params();
-entityWithReadOnlyAttribute
-    .update({ prop1: "abc", prop2: "def" })
-    .remove(["prop4"])
-    .params();
-entityWithReadOnlyAttribute
-    .update({ prop1: "abc", prop2: "def" })
-    .add({
-    prop5: 13,
-})
-    .params();
-entityWithReadOnlyAttribute
-    .update({ prop1: "abc", prop2: "def" })
-    .subtract({
-    prop5: 13,
-})
-    .params();
-entityWithReadOnlyAttribute
-    .update({ prop1: "abc", prop2: "def" })
-    .append({
-    prop6: ["value"],
-})
-    .params();
-entityWithReadOnlyAttribute
-    .update({ prop1: "abc", prop2: "def" })
-    .delete({
-    prop6: ["value"],
-})
-    .params();
-// full chain with duplicates
-entityWithReadOnlyAttribute
-    .update({ prop1: "abc", prop2: "def" })
-    .set(setItemValue)
-    .remove(["prop4"])
-    .add({
-    prop5: 13,
-})
-    .subtract({
-    prop5: 13,
-})
-    .append({
-    prop6: ["value"],
-})
-    .delete({
-    prop6: ["value"],
-})
-    .set(setItemValue)
-    .remove(["prop4"])
-    .data((attr, op) => {
-    op.set(attr.prop4, "abc");
-    op.set(attr.prop5, 134);
-    op.set(attr.prop6, "def");
-    op.set(attr.prop6, 123);
-    op.set(attr.prop6, true);
-    op.set(attr.prop6[1], true);
-    op.set(attr.prop6.prop1, true);
-    op.set(attr.prop8, "def");
-    op.remove(attr.prop4);
-    op.remove(attr.prop5);
-    op.remove(attr.prop6);
-    op.remove(attr.prop6);
-    op.remove(attr.prop6);
-    op.remove(attr.prop6[1]);
-    op.remove(attr.prop6.prop1);
-    op.remove(attr.prop8);
-    op.append(attr.prop6, ["abc"]);
-    op.append(attr.prop6, ["abc"]);
-    op.append(attr.prop6, ["abc"]);
-    op.append(attr.prop6[1], ["abc"]);
-    op.append(attr.prop6.prop1, ["abc"]);
-    op.delete(attr.prop6, ["abc"]);
-    op.delete(attr.prop6, ["abc"]);
-    op.delete(attr.prop6, ["abc"]);
-    op.delete(attr.prop6[1], ["abc"]);
-    op.delete(attr.prop6.prop1, ["abc"]);
-    op.del(attr.prop6, ["abc"]);
-    op.del(attr.prop6, ["abc"]);
-    op.del(attr.prop6, ["abc"]);
-    op.del(attr.prop6[1], ["abc"]);
-    op.del(attr.prop6.prop1, ["abc"]);
-    op.name(attr.prop4);
-    op.name(attr.prop5);
-    op.name(attr.prop6);
-    op.name(attr.prop6);
-    op.name(attr.prop6);
-    op.name(attr.prop6[1]);
-    op.name(attr.prop6.prop1);
-    op.name(attr.prop8);
-    op.value(attr.prop4, "abc");
-    op.value(attr.prop5, 134);
-    op.value(attr.prop6, "abc");
-    op.value(attr.prop6, "abc");
-    op.value(attr.prop6, "abc");
-    op.value(attr.prop6[1], "abc");
-    op.value(attr.prop6.prop1, "abc");
-    op.value(attr.prop8, "abc");
-})
-    .add({
-    prop5: 13,
-})
-    .subtract({
-    prop5: 13,
-})
-    .append({
-    prop6: ["value"],
-})
-    .delete({
-    prop6: ["value"],
-})
-    .params();
-const names = "";
-// complexService.collections
-//     .mycollection1({attr9: 123, attr6: 245})
-//     .page()
-//     .then(([next, results]) => {
-//         expectType<string | undefined>(next?.attr1);
-//         expectType<string | undefined>(next?.attr2);
-//         expectType<number | undefined>(next?.attr6);
-//         expectType<number | undefined>(next?.attr9);
-//         expectType<"abc" | "def" |  "ghi" | undefined>(next?.attr4);
-//         expectType<string | undefined>(next?.attr5);
-//         expectType<number | undefined>(next?.prop5);
-//         expectType<string | undefined>(next?.prop1);
-//         expectType<string | undefined>(next?.prop2);
-//         expectType<string | undefined>(next?.__edb_e__);
-//         expectType<string | undefined>(next?.__edb_v__);
-//         expectAssignable<typeof next>({
-//             attr1: "abc",
-//             attr2: "abc",
-//             attr6: 27,
-//             attr9: 89,
-//             attr4: "abc",
-//             attr5: "abc",
-//             __edb_e__: "entityWithSK",
-//             __edb_v__: "1"
-//         });
-//         expectAssignable<typeof next>({
-//             prop1: "abc",
-//             prop2: "abc",
-//             attr6: 27,
-//             attr9: 89,
-//             prop5: 12,
-//             __edb_e__: "normalEntity2",
-//             __edb_v__: "1"
-//         });
-//         expectAssignable<typeof next>({
-//             attr1: "abc",
-//             attr6: 27,
-//             attr9: 89,
-//             __edb_e__: "entityWithoutSK",
-//             __edb_v__: "1"
-//         });
-//         expectType<keyof typeof results>(names);
-//         expectNotType<any>(next);
-//     })
-complexService.collections
-    .mycollection1({ attr9: 123, attr6: 245 })
-    .go({ cursor: null });
-complexService.collections
-    .mycollection1({ attr9: 123, attr6: 245 })
-    .go({ cursor: "abc" });
-complexService.entities.entityWithSK
-    .remove({ attr1: "abc", attr2: "def" })
-    .where((attr, op) => op.eq(attr.attr9, 14))
-    .go();
-const entityWithMultipleCollections1 = new _1.Entity({
-    model: {
-        entity: "entity1",
-        service: "myservice",
-        version: "myversion",
-    },
-    attributes: {
-        attr1: {
-            type: "string",
-        },
-        attr2: {
-            type: "string",
-        },
-    },
-    indexes: {
-        myIndex: {
-            collection: ["outercollection", "innercollection"],
-            pk: {
-                field: "pk",
-                composite: ["attr1"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["attr2"],
-            },
-        },
-    },
-});
-const entityWithMultipleCollections2 = new _1.Entity({
-    model: {
-        entity: "entity2",
-        service: "myservice",
-        version: "myversion",
-    },
-    attributes: {
-        attr1: {
-            type: "string",
-        },
-        attr2: {
-            type: "string",
-        },
-    },
-    indexes: {
-        myIndex: {
-            collection: ["outercollection", "innercollection"],
-            pk: {
-                field: "pk",
-                composite: ["attr1"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["attr2"],
-            },
-        },
-        myIndex2: {
-            index: "index2",
-            collection: ["extracollection"],
-            pk: {
-                field: "index2pk",
-                composite: ["attr1"],
-            },
-            sk: {
-                field: "index2sk",
-                composite: ["attr2"],
-            },
-        },
-    },
-});
-const entityWithMultipleCollections3 = new _1.Entity({
-    model: {
-        entity: "entity3",
-        service: "myservice",
-        version: "myversion",
-    },
-    attributes: {
-        attr1: {
-            type: "string",
-        },
-        attr2: {
-            type: "string",
-        },
-    },
-    indexes: {
-        myIndex: {
-            collection: "outercollection",
-            pk: {
-                field: "pk",
-                composite: ["attr1"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["attr2"],
-            },
-        },
-        myIndex2: {
-            index: "index2",
-            collection: "extracollection",
-            pk: {
-                field: "index2pk",
-                composite: ["attr1"],
-            },
-            sk: {
-                field: "index2sk",
-                composite: ["attr2"],
-            },
-        },
-    },
-});
-const serviceWithMultipleCollections = new _1.Service({
-    entityWithMultipleCollections3,
-    entityWithMultipleCollections1,
-    entityWithMultipleCollections2,
-});
-serviceWithMultipleCollections.collections
-    .outercollection({ attr1: "abc" })
-    .go()
-    .then((res) => {
-    const keys = "";
-    (0, tsd_1.expectType)(keys);
-});
-serviceWithMultipleCollections.collections
-    .innercollection({ attr1: "abc" })
-    .go()
-    .then((res) => {
-    const keys = "";
-    (0, tsd_1.expectType)(keys);
-});
-serviceWithMultipleCollections.collections
-    .extracollection({ attr1: "abc" })
-    .go()
-    .then((res) => {
-    const keys = "";
-    (0, tsd_1.expectType)(keys);
-});
-const entityWithWatchAll = new _1.Entity({
-    model: {
-        entity: "withwatchall",
-        service: "service",
-        version: "1",
-    },
-    attributes: {
-        prop1: {
-            type: "string",
-        },
-        prop2: {
-            type: "string",
-        },
-        prop3: {
-            type: "string",
-            watch: "*",
-            set: (value) => {
-                return value;
-            },
-        },
-    },
-    indexes: {
-        record: {
-            pk: {
-                field: "pk",
-                composite: ["prop1"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["prop2"],
-            },
-        },
-    },
-});
-const entityWithComplexShapes = new _1.Entity({
-    model: {
-        entity: "entity",
-        service: "service",
-        version: "1",
-    },
-    attributes: {
-        prop1: {
-            type: "string",
-            label: "props",
-        },
-        prop2: {
-            type: "string",
-        },
-        prop3: {
-            type: "map",
-            properties: {
-                val1: {
-                    type: "string",
-                },
-            },
-        },
-        prop4: {
-            type: "list",
-            items: {
-                type: "map",
-                properties: {
-                    val2: {
-                        type: "number",
-                    },
-                    val3: {
-                        type: "list",
-                        items: {
-                            type: "string",
-                        },
-                    },
-                    val4: {
-                        type: "set",
-                        items: "number",
-                    },
-                },
-            },
-        },
-        prop5: {
-            type: "set",
-            items: "string",
-        },
-        prop6: {
-            type: "set",
-            items: "string",
-        },
-    },
-    indexes: {
-        record: {
-            collection: "mops",
-            pk: {
-                field: "pk",
-                composite: ["prop1"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["prop2"],
-            },
-        },
-    },
-});
-const entityWithComplexShapesRequired = new _1.Entity({
-    model: {
-        entity: "entity",
-        service: "service",
-        version: "1",
-    },
-    attributes: {
-        prop1: {
-            type: "string",
-            label: "props",
-        },
-        prop2: {
-            type: "string",
-        },
-        attr3: {
-            type: "map",
-            properties: {
-                val1: {
-                    type: "string",
-                    required: true,
-                },
-            },
-            required: true,
-        },
-        attr4: {
-            type: "list",
-            items: {
-                type: "map",
-                properties: {
-                    val2: {
-                        type: "number",
-                        required: true,
-                    },
-                    val3: {
-                        type: "list",
-                        items: {
-                            type: "string",
-                            required: true,
-                        },
-                        required: true,
-                    },
-                    val4: {
-                        type: "set",
-                        items: "number",
-                        required: true,
-                    },
-                },
-            },
-            required: true,
-        },
-        attr5: {
-            type: "set",
-            items: "string",
-            required: true,
-        },
-        attr6: {
-            type: "set",
-            items: "string",
-            required: true,
-        },
-    },
-    indexes: {
-        record: {
-            collection: "mops",
-            pk: {
-                field: "pk",
-                composite: ["prop1"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["prop2"],
-            },
-        },
-    },
-});
-const entityWithComplexShapesRequiredOnEdge = new _1.Entity({
-    model: {
-        entity: "entity",
-        service: "service",
-        version: "1",
-    },
-    attributes: {
-        prop1: {
-            type: "string",
-            label: "props",
-        },
-        prop2: {
-            type: "string",
-        },
-        attrz3: {
-            type: "map",
-            properties: {
-                val1: {
-                    type: "string",
-                    required: true,
-                    validate: /./gi,
-                },
-            },
-        },
-        attrz4: {
-            type: "list",
-            items: {
-                type: "map",
-                properties: {
-                    val2: {
-                        type: "number",
-                        required: true,
-                    },
-                    val3: {
-                        type: "list",
-                        items: {
-                            type: "string",
-                            required: true,
-                        },
-                    },
-                    val4: {
-                        type: "set",
-                        items: "number",
-                    },
-                    val5: {
-                        type: "map",
-                        properties: {
-                            val6: {
-                                type: "string",
-                                required: true,
-                            },
-                        },
-                    },
-                },
-            },
-        },
-        attrz5: {
-            type: "set",
-            items: "string",
-        },
-        attrz6: {
-            type: "set",
-            items: "string",
-        },
-    },
-    indexes: {
-        record: {
-            collection: "mops",
-            pk: {
-                field: "pk",
-                composite: ["prop1"],
-            },
-            sk: {
-                field: "sk",
-                composite: ["prop2"],
-            },
-        },
-    },
-});
-const complexShapeService = new _1.Service({
-    ent1: entityWithComplexShapesRequiredOnEdge,
-    ent2: entityWithComplexShapes,
-    ent3: entityWithComplexShapesRequired,
-});
-const parsed = entityWithComplexShapes.parse({});
-entityWithComplexShapes.query
-    .record({ prop1: "abc" })
-    .go()
-    .then((res) => {
-    (0, tsd_1.expectType)(entityWithComplexShapes.parse({
-        Items: [],
-    }));
-});
-(0, tsd_1.expectError)(() => {
-    entityWithSK.parse({ Items: [] }, {
-        attributes: ["attr1", "oops"],
-    });
-});
-const parsedWithAttributes = entityWithSK.parse({ Items: [] }, {
-    attributes: ["attr1", "attr2", "attr3"],
-});
-const parsedWithAttributesSingle = entityWithSK.parse({ Item: {} }, {
-    attributes: ["attr1", "attr2", "attr3"],
-});
-(0, tsd_1.expectType)(magnify(parsedWithAttributes.data));
-(0, tsd_1.expectType)(magnify(parsedWithAttributesSingle.data));
-entityWithComplexShapes
-    .get({ prop1: "abc", prop2: "def" })
-    .go()
-    .then((res) => {
-    (0, tsd_1.expectType)(res);
-    if (res.data === null) {
-        return null;
-    }
-    res.data.prop3?.val1;
-    let int = 0;
-    if (Array.isArray(res.data.prop4)) {
-        for (let value of res.data.prop4) {
-            if (typeof value === "string") {
-                if (isNaN(parseInt(value))) {
-                    int += 0;
-                }
-                else {
-                    int += parseInt(value);
-                }
-            }
-            else if (typeof value === "number") {
-                int += value;
-            }
-            else if (Array.isArray(value)) {
-                for (let val of value) {
-                    int += val.val2;
-                }
-            }
-            else {
-                (0, tsd_1.expectType)(value.val2);
-                int += value?.val2 ?? 0;
-            }
-        }
-    }
-    return res.data.prop3?.val1;
-});
-entityWithComplexShapes
-    .get({ prop1: "abc", prop2: "def" })
-    .go()
-    .then((res) => {
-    if (res.data !== null) {
-        res.data.prop5?.map((values) => values);
-        res.data.prop6?.map((values) => values);
-    }
-});
-entityWithComplexShapes
-    .update({ prop1: "abc", prop2: "def" })
-    .set({
-    prop4: [
-        {
-            val2: 789,
-            val3: ["123"],
-            val4: [123, 456],
-        },
-    ],
-    prop5: ["abc"],
-})
-    .go();
-entityWithComplexShapes
-    .put({
-    prop1: "abc",
-    prop2: "def",
-    prop4: [
-        {
-            val2: 789,
-            val3: ["123"],
-            val4: [123, 456],
-        },
-    ],
-    prop5: ["abc"],
-})
-    .go();
-entityWithComplexShapes
-    .update({ prop1: "abc", prop2: "def" })
-    .set({
-    prop4: [
-        {
-            val2: 789,
-            val3: ["123"],
-            // val4: [1, 2, 3]
-        },
-    ],
-    prop5: ["abc"],
-})
-    .where(({ prop5 }, { eq }) => eq(prop5, ["abc"]))
-    .where(({ prop1 }, { eq }) => eq(prop1, "abc"))
-    .go();
-entityWithComplexShapes
-    .update({ prop1: "abc", prop2: "def" })
-    .append({
-    prop4: [
-        {
-            val2: 789,
-            val3: ["123"],
-            val4: [1, 2, 3],
-        },
-    ],
-})
-    .data(({ prop5, prop4 }, { add, append, remove }) => {
-    add(prop5, ["abc"]);
-    append(prop4[0].val3, ["123"]);
-    append(prop4, [
-        {
-            val2: 789,
-            val3: ["123"],
-            val4: [1, 2, 3],
-        },
-    ]);
-    add(prop4[0].val2, 789);
-    add(prop4[0].val4, [1]);
-    remove(prop4[0].val4);
-    remove(prop4[0].val3);
-    remove(prop4[0].val2);
-})
-    .go();
-(0, tsd_1.expectError)(() => {
-    entityWithComplexShapes
-        .update({ prop1: "abc", prop2: "def" })
-        .append({
-        prop4: [
-            {
-                val2: 789,
-                val3: ["123"],
-                val4: [1, 2, 3],
-            },
-        ],
-        prop5: ["abc"],
-    })
-        .go();
-});
-const updateWithWhere = entityWithComplexShapes
-    .update({
-    prop1: "abc",
-    prop2: "def",
-})
-    .data((attr, op) => { })
-    .where((attr, op) => op.eq(attr.prop3.val1, "def")).go;
-const updateWithoutWhere = entityWithComplexShapes
-    .update({
-    prop1: "abc",
-    prop2: "def",
-})
-    .data((attr, op) => { }).go;
-const updateWithWhereGoOption = {};
-const updateWithOutWhereGoOptions = {};
-(0, tsd_1.expectType)(updateWithWhereGoOption);
-(0, tsd_1.expectType)(updateWithOutWhereGoOptions);
-entityWithComplexShapes
-    .update({
-    prop1: "abc",
-    prop2: "def",
-})
-    .data((attr, op) => { })
-    .where((attr, op) => op.eq(attr.prop3.val1, "def"))
-    .go({})
-    .then((res) => {
-    (0, tsd_1.expectType)(res);
-});
-entityWithComplexShapes
-    .patch({
-    prop1: "abc",
-    prop2: "def",
-})
-    .data((attr, op) => { })
-    .where((attr, op) => op.eq(attr.prop3.val1, "def"))
-    .go({
-    response: "all_new",
-})
-    .then((res) => {
-    (0, tsd_1.expectType)(res.data);
-});
-entityWithComplexShapes
-    .update({
-    prop1: "abc",
-    prop2: "def",
-})
-    .set({})
-    .where((attr, op) => op.eq(attr.prop3.val1, "def"))
-    .go({
-    originalErr: true,
-})
-    .then((res) => {
-    (0, tsd_1.expectType)(magnify(res.data));
-});
-entityWithComplexShapes
-    .update({
-    prop1: "abc",
-    prop2: "def",
-})
-    .set({ prop6: ["sb"] })
-    .data((attr, op) => {
-    op.append(attr.prop5, ["sweet"]);
-})
-    .where((attr, op) => op.eq(attr.prop2, "def"))
-    .go({})
-    .then((res) => {
-    (0, tsd_1.expectType)(res);
-});
-entityWithComplexShapes
-    .remove({
-    prop1: "abc",
-    prop2: "def",
-})
-    .where((attr, op) => op.eq(attr.prop3.val1, "def"))
-    .go({
-    response: "all_old",
-});
-entityWithComplexShapes
-    .put({
-    prop1: "abc",
-    prop2: "def",
-})
-    .where((attr, op) => op.eq(attr.prop3.val1, "def"))
-    .go({
-    response: "all_old",
-});
-(0, tsd_1.expectError)(() => {
-    entityWithComplexShapes
-        .update({ prop1: "abc", prop2: "def" })
-        .data(({ prop1 }, { remove }) => {
-        remove(prop1);
-    })
-        .go();
-});
-entityWithComplexShapes
-    .update({ prop1: "abc", prop2: "def" })
-    .set({
-    prop4: [
-        {
-            val2: 789,
-            val3: ["123"],
-            val4: [1, 2, 3],
-        },
-    ],
-    prop5: ["abc"],
-})
-    .go();
-entityWithComplexShapesRequired.put({
-    prop1: "abc",
-    prop2: "def",
-    attr3: {
-        val1: "abc",
-    },
-    attr4: [
-        {
-            val2: 789,
-            val3: ["123"],
-            val4: [1, 2, 3],
-        },
-    ],
-    attr5: ["abc"],
-    attr6: ["abdbdb"],
-});
-(0, tsd_1.expectError)(() => {
-    entityWithComplexShapesRequired.put({});
-});
-(0, tsd_1.expectError)(() => {
-    entityWithComplexShapesRequired.put({ prop1: "abc", prop2: "def" });
-});
-complexShapeService.collections.mops({ prop1: "abc" }).where((a, op) => {
-    op.eq(a.attr3.val1, "abd");
-    (0, tsd_1.expectError)(() => op.eq(a.attr3, "abc"));
-    (0, tsd_1.expectError)(() => op.eq(a.attr3.val2, "abc"));
-    (0, tsd_1.expectError)(() => op.eq(a.attr3.val1, 123));
-    op.between(a.attr4[0].val2, 789, 888);
-    (0, tsd_1.expectError)(() => op.eq(a.attr4, "abc"));
-    (0, tsd_1.expectError)(() => op.eq(a.attr4.val2, "abc"));
-    (0, tsd_1.expectError)(() => op.eq(a.attr4[0].val2, "456"));
-    op.between(a.attr4[0].val3[1], "xyz", "123");
-    // expectNotAssignable<"abc">(a.attr4[1].val3[1]);
-    // expectNotAssignable<typeof (a.attr4[1].val3)>(["abc"]);
-    // expectError(() => op.eq(a.attr4[1].val3["def"], "xyz"));
-    op.gte(a.attr5, ["abc"]);
-    op.eq(a.attrz3.val1, "abd");
-    (0, tsd_1.expectError)(() => op.eq(a.attrz3, "abc"));
-    (0, tsd_1.expectError)(() => op.eq(a.attrz3.val2, "abc"));
-    (0, tsd_1.expectError)(() => op.eq(a.attrz3.val1, 123));
-    op.between(a.attrz4[0].val2, 789, 888);
-    // expectNotAssignable<"abc">(a.attrz4[1].val3[1]);
-    // expectNotAssignable<["abc"]>(a.attrz4[1].val3);
-    (0, tsd_1.expectError)(() => op.eq(a.attrz4[0].val2, "456"));
-    op.between(a.attrz4[0].val3[1], "xyz", "123");
-    // expectError(() => op.eq(a.attr4[1].val3[1], "abc"));
-    // expectError(() => op.eq(a.attr4[1].val3["def"], "xyz"));
-    op.gte(a.attrz5, ["abc"]);
-    op.eq(a.prop3.val1, "abd");
-    (0, tsd_1.expectError)(() => op.eq(a.attrz3, "abc"));
-    (0, tsd_1.expectError)(() => op.eq(a.attrz3.val2, "abc"));
-    (0, tsd_1.expectError)(() => op.eq(a.attrz3.val1, 123));
-    op.between(a.prop4[0].val2, 789, 888);
-    op.between(a.prop4[0].val3[1], "xyz", "123");
-    op.gte(a.prop5, ["abc"]);
-    op.eq(a.prop2, "def");
-    op.contains(a.prop4[1].val3[2], "123");
-    return "";
-});
-const complex = new _1.Entity({
-    model: {
-        entity: "user",
-        service: "versioncontrol",
-        version: "1",
-    },
-    attributes: {
-        username: {
-            type: "string",
-        },
-        stringVal: {
-            type: "string",
-            default: () => "abc",
-            validate: (value) => value !== undefined,
-            get: (value) => {
-                return value;
-            },
-            set: (value) => {
-                return value;
-            },
-        },
-        enumVal: {
-            type: ["abc", "def"],
-            validate: (value) => value !== undefined,
-            default: () => "abc",
-            get: (value) => {
-                return value;
-            },
-            set: (value) => {
-                return value;
-            },
-        },
-        numVal: {
-            type: "number",
-            validate: (value) => value !== undefined,
-            default: () => 123,
-            get: (value) => {
-                return value;
-            },
-            set: (value) => {
-                return value;
-            },
-        },
-        boolValue: {
-            type: "boolean",
-            validate: (value) => value !== undefined,
-            default: () => true,
-            get: (value) => {
-                return value;
-            },
-            set: (value) => {
-                return value;
-            },
-        },
-        stringSetValue: {
-            type: "set",
-            items: "string",
-            validate: (value) => value !== undefined,
-            default: () => ["abc"],
-            get: (value) => {
-                return value;
-            },
-            set: (value) => {
-                return value;
-            },
-        },
-        numberSetValue: {
-            type: "set",
-            items: "number",
-            validate: (value) => value !== undefined,
-            default: () => [1],
-            get: (value) => {
-                return value;
-            },
-            set: (value) => {
-                return value;
-            },
-        },
-        stringListValue: {
-            type: "list",
-            items: {
-                type: "string",
-                default: "abc",
-                validate: (value) => value !== undefined,
-                get: (value) => {
-                    return value;
-                },
-                set: (value) => {
-                    return value;
-                },
-            },
-            default: ["abc"],
-            validate: (value) => value !== undefined,
-            get: (value) => {
-                return value;
-            },
-            set: (value) => {
-                return value;
-            },
-        },
-        numberListValue: {
-            type: "list",
-            items: {
-                type: "number",
-                validate: (value) => value !== undefined,
-                default: 0,
-                get: (value) => {
-                    return value;
-                },
-                set: (value) => {
-                    return value;
-                },
-            },
-            default: [],
-            validate: (value) => value !== undefined,
-            get: (value) => {
-                return value;
-            },
-            set: (value) => {
-                return value;
-            },
-        },
-        mapListValue: {
-            type: "list",
-            items: {
-                type: "map",
-                properties: {
-                    stringVal: {
-                        type: "string",
-                        default: "def",
-                        validate: (value) => value !== undefined,
-                        get: (value) => {
-                            return value;
-                        },
-                        set: (value) => {
-                            return value;
-                        },
-                    },
-                    numVal: {
-                        type: "number",
-                        default: 5,
-                        validate: (value) => value !== undefined,
-                        get: (value) => {
-                            return value;
-                        },
-                        set: (value) => {
-                            return value;
-                        },
-                    },
-                    boolValue: {
-                        type: "boolean",
-                        default: false,
-                        validate: (value) => value !== undefined,
-                        get: (value) => {
-                            return value;
-                        },
-                        set: (value) => {
-                            return value;
-                        },
-                    },
-                    enumVal: {
-                        type: ["abc", "def"],
-                        validate: (value) => value !== undefined,
-                        default: () => "abc",
-                        get: (value) => {
-                            return value;
-                        },
-                        set: (value) => {
-                            return value;
-                        },
-                    },
-                },
-                validate: (value) => value !== undefined,
-                default: {
-                    stringVal: "abc",
-                    numVal: 123,
-                    boolValue: false,
-                },
-                get: (value) => {
-                    return value;
-                },
-                set: (value) => {
-                    return value;
-                },
-            },
-            get: (value) => {
-                return value;
-            },
-            set: (value) => {
-                return value;
-            },
-        },
-        mapValue: {
-            type: "map",
-            properties: {
-                stringVal: {
-                    type: "string",
-                    default: () => "abc",
-                    validate: (value) => value !== undefined,
-                    get: (value) => {
-                        return value;
-                    },
-                    set: (value) => {
-                        return value;
-                    },
-                },
-                numVal: {
-                    type: "number",
-                    default: () => 10,
-                    validate: (value) => value !== undefined,
-                    get: (value) => {
-                        return value;
-                    },
-                    set: (value) => {
-                        return value;
-                    },
-                },
-                boolValue: {
-                    type: "boolean",
-                    default: () => false,
-                    validate: (value) => value !== undefined,
-                    get: (value) => {
-                        return value;
-                    },
-                    set: (value) => {
-                        return value;
-                    },
-                },
-                enumVal: {
-                    type: ["abc", "def"],
-                    validate: (value) => value !== undefined,
-                    default: () => "abc",
-                    get: (value) => {
-                        return value;
-                    },
-                    set: (value) => {
-                        return value;
-                    },
-                },
-                stringListValue: {
-                    type: "list",
-                    items: {
-                        type: "string",
-                        default: "abc",
-                        validate: (value) => value !== undefined,
-                        get: (value) => {
-                            return value;
-                        },
-                        set: (value) => {
-                            return value;
-                        },
-                    },
-                    default: [],
-                    validate: (value) => value !== undefined,
-                    get: (value) => {
-                        return value;
-                    },
-                    set: (value) => {
-                        return value;
-                    },
-                },
-                numberListValue: {
-                    type: "list",
-                    items: {
-                        type: "number",
-                        default: () => 100,
-                        validate: (value) => value !== undefined,
-                        get: (value) => {
-                            return value;
-                        },
-                        set: (value) => {
-                            return value;
-                        },
-                    },
-                    default: [123, 123],
-                    validate: (value) => value !== undefined,
-                    get: (value) => {
-                        return value;
-                    },
-                    set: (value) => {
-                        return value;
-                    },
-                },
-                mapListValue: {
-                    type: "list",
-                    items: {
-                        type: "map",
-                        properties: {
-                            stringVal: {
-                                type: "string",
-                                default: "def",
-                                validate: (value) => value !== undefined,
-                                get: (value) => {
-                                    return value;
-                                },
-                                set: (value) => {
-                                    return value;
-                                },
-                            },
-                            numVal: {
-                                type: "number",
-                                default: 100,
-                                validate: (value) => value !== undefined,
-                                get: (value) => {
-                                    return value;
-                                },
-                                set: (value) => {
-                                    return value;
-                                },
-                            },
-                            boolValue: {
-                                type: "boolean",
-                                default: () => false,
-                                validate: (value) => value !== undefined,
-                                get: (value) => {
-                                    return value;
-                                },
-                                set: (value) => {
-                                    return value;
-                                },
-                            },
-                            stringSetValue: {
-                                type: "set",
-                                items: "string",
-                                default: ["abc"],
-                                validate: (value) => value !== undefined,
-                                get: (value) => {
-                                    return value;
-                                },
-                                set: (value) => {
-                                    return value;
-                                },
-                            },
-                            numberSetValue: {
-                                type: "set",
-                                items: "number",
-                                default: [5],
-                                validate: (value) => value !== undefined,
-                                get: (value) => {
-                                    return value;
-                                },
-                                set: (value) => {
-                                    return value;
-                                },
-                            },
-                            enumVal: {
-                                type: ["abc", "def"],
-                                validate: (value) => value !== undefined,
-                                default: () => "abc",
-                                get: (value) => {
-                                    return value;
-                                },
-                                set: (value) => {
-                                    return value;
-                                },
-                            },
-                        },
-                        default: () => ({
-                            stringVal: "anx",
-                            numVal: 13,
-                            boolValue: true,
-                            emumValue: "abc",
-                            stringSetValue: ["def"],
-                            numberSetValue: [10],
-                        }),
-                        validate: (value) => value !== undefined,
-                        get: (value) => {
-                            return value;
-                        },
-                        set: (value) => {
-                            return value;
-                        },
-                    },
-                    default: [],
-                    validate: (value) => value !== undefined,
-                    get: (value) => {
-                        return value;
-                    },
-                    set: (value) => {
-                        return value;
-                    },
-                },
-            },
-            default: () => undefined,
-            validate: (value) => value !== undefined,
-            get: (value) => {
-                return value;
-            },
-            set: (value) => {
-                return value;
-            },
-        },
-    },
-    indexes: {
-        user: {
-            collection: "complexShapes",
-            pk: {
-                composite: ["username"],
-                field: "pk",
-            },
-            sk: {
-                composite: [],
-                field: "sk",
-            },
-        },
-        _: {
-            collection: "owned",
-            index: "gsi1pk-gsi1sk-index",
-            pk: {
-                composite: ["username"],
-                field: "gsi1pk",
-            },
-            sk: {
-                field: "gsi1sk",
-                composite: [],
-            },
-        },
-    },
-}, { table: "abc" });
-const mapTests = new _1.Entity({
-    model: {
-        entity: "mapTests",
-        service: "tests",
-        version: "1",
-    },
-    attributes: {
-        username: {
-            type: "string",
-        },
-        mapObject: {
-            type: "map",
-            properties: {
-                minimal: {
-                    type: "string",
-                },
-                required: {
-                    type: "string",
-                    required: true,
-                },
-                hidden: {
-                    type: "string",
-                    hidden: true,
-                },
-                readOnly: {
-                    type: "string",
-                    readOnly: true,
-                },
-                anotherMap: {
-                    type: "map",
-                    properties: {
-                        minimal: {
-                            type: "string",
-                        },
-                        required: {
-                            type: "string",
-                            required: true,
-                        },
-                        hidden: {
-                            type: "string",
-                            hidden: true,
-                        },
-                        readOnly: {
-                            type: "string",
-                            readOnly: true,
-                        },
-                    },
-                },
-            },
-        },
-    },
-    indexes: {
-        user: {
-            collection: "complexShapes",
-            pk: {
-                composite: ["username"],
-                field: "pk",
-            },
-            sk: {
-                composite: [],
-                field: "sk",
-            },
-        },
-    },
-});
-const complexAttributeService = new _1.Service({
-    mapTests,
-    complex,
-});
-mapTests
-    .get({ username: "test" })
-    .go()
-    .then((res) => {
-    const data = res.data;
-    if (data && data.mapObject !== undefined) {
-        (0, tsd_1.expectError)(() => {
-            data.mapObject?.hidden;
-        });
-        (0, tsd_1.expectType)(data.mapObject.minimal);
-        (0, tsd_1.expectType)(data.mapObject.readOnly);
-        (0, tsd_1.expectType)(data.mapObject.required);
-    }
-});
-// just the key is fine because `mapObject` is not required
-(0, tsd_1.expectAssignable)([{ username: "abc" }]);
-// with mapObject present, `required` is required
-mapTests.put({ username: "abc", mapObject: { required: "val" } });
-mapTests.put([{ username: "abc", mapObject: { required: "val" } }]);
-(0, tsd_1.expectError)(() => {
-    mapTests.put({ username: "abc", mapObject: { minimal: "abc" } });
-});
-(0, tsd_1.expectError)(() => {
-    mapTests.put([{ username: "abc", mapObject: { minimal: "abc" } }]);
-});
-// with anotherMap present, `required` is required
-mapTests.put({
-    username: "abc",
-    mapObject: { required: "val", anotherMap: { required: "def" } },
-});
-mapTests.put([
-    {
-        username: "abc",
-        mapObject: { required: "val", anotherMap: { required: "def" } },
-    },
-]);
-(0, tsd_1.expectError)(() => {
-    mapTests.put({
-        username: "abc",
-        mapObject: { minimal: "abc", required: "def", anotherMap: {} },
-    });
-});
-(0, tsd_1.expectError)(() => {
-    mapTests.put([
-        {
-            username: "abc",
-            mapObject: { minimal: "abc", required: "def", anotherMap: {} },
-        },
-    ]);
-});
-//
-mapTests.update({ username: "abc" }).data((attr, op) => {
-    (0, tsd_1.expectError)(() => op.set(attr.mapObject.readOnly, "abc"));
-    (0, tsd_1.expectError)(() => op.set(attr.mapObject.anotherMap.readOnly, "abc"));
-    op.set(attr.mapObject.minimal, "abc");
-    op.set(attr.mapObject.anotherMap.minimal, "abc");
-    op.set(attr.mapObject.hidden, "abc");
-    op.set(attr.mapObject.anotherMap.hidden, "abc");
-    op.set(attr.mapObject.required, "abc");
-    op.set(attr.mapObject.anotherMap.required, "abc");
-    // START SHOULD FAIL :(
-    // expectError(() => op.remove(attr.mapObject.readOnly));
-    // expectError(() => op.remove(attr.mapObject.required));
-    // expectError(() => op.set(attr.mapObject, {}));
-    // expectError(() => op.set(attr.mapObject, {minimal: "abc"}));
-    // END SHOULD FAIL :(
-    op.set(attr.mapObject, { required: "anc" });
-});
-(0, tsd_1.expectError)(() => mapTests.update({ username: "abc" }).remove(["username"]));
-complexAttributeService.collections
-    .complexShapes({ username: "abc" })
-    .where((attr, op) => {
-    op.eq(attr.mapObject.minimal, "abc");
-    op.eq(attr.numberListValue[0], 123);
-    op.eq(attr.mapListValue[1].enumVal, "def");
-    op.eq(attr.mapListValue[1].numVal, 345);
-    return "";
-})
-    .go();
-// casing property on schema
-const casingEntity = new _1.Entity({
-    model: {
-        service: "MallStoreDirectory",
-        entity: "MallStores",
-        version: "1",
-    },
-    attributes: {
-        id: {
-            type: "string",
-            field: "id",
-        },
-        mall: {
-            type: "string",
-            required: true,
-            field: "mall",
-        },
-        stores: {
-            type: "number",
-        },
-        value: {
-            type: "string",
-        },
-    },
-    indexes: {
-        store: {
-            collection: ["myCollection"],
-            pk: {
-                field: "parition_key",
-                composite: ["id"],
-                casing: "lower",
-            },
-            sk: {
-                field: "sort_key",
-                composite: ["mall", "stores"],
-                casing: "upper",
-            },
-        },
-        other: {
-            index: "idx1",
-            collection: "otherCollection",
-            pk: {
-                field: "parition_key_idx1",
-                composite: ["mall"],
-                casing: "upper",
-            },
-            sk: {
-                field: "sort_key_idx1",
-                composite: ["id", "stores"],
-                casing: "default",
-            },
-        },
-    },
-}, { table: "StoreDirectory" });
-const allCasingOptions = "";
-(0, tsd_1.expectAssignable)(allCasingOptions);
-(0, tsd_1.expectAssignable)(allCasingOptions);
-(0, tsd_1.expectError)("not_available");
-(0, tsd_1.expectError)("not_available");
-(0, tsd_1.expectAssignable)(undefined);
-(0, tsd_1.expectAssignable)({});
-(0, tsd_1.expectAssignable)({ ignoreOwnership: true });
-(0, tsd_1.expectAssignable)({ ignoreOwnership: false });
-normalEntity2
-    .update({
-    prop1: "abc",
-    prop2: "def",
-    prop5: 123,
-})
-    .set({ attr6: 456 })
-    .go()
-    .then((results) => {
-    (0, tsd_1.expectType)(magnify(results.data));
-});
-normalEntity2
-    .update({
-    prop1: "abc",
-    prop2: "def",
-    prop5: 123,
-})
-    .set({ attr6: 456 })
-    .go({ response: "updated_new" })
-    .then((results) => {
-    (0, tsd_1.expectType)(magnify(results.data));
-});
-normalEntity2
-    .update({
-    prop1: "abc",
-    prop2: "def",
-    prop5: 123,
-})
-    .set({ attr6: 456 })
-    .go({ response: "all_new" })
-    .then((results) => {
-    (0, tsd_1.expectType)(magnify(results.data));
-});
-normalEntity2
-    .patch({
-    prop1: "abc",
-    prop2: "def",
-    prop5: 123,
-})
-    .set({ attr6: 456 })
-    .go()
-    .then((results) => {
-    (0, tsd_1.expectType)(magnify(results.data));
-});
-normalEntity2
-    .patch({
-    prop1: "abc",
-    prop2: "def",
-    prop5: 123,
-})
-    .set({ attr6: 456 })
-    .go({ response: "updated_new" })
-    .then((results) => {
-    (0, tsd_1.expectType)(magnify(results.data));
-});
-normalEntity2
-    .patch({
-    prop1: "abc",
-    prop2: "def",
-    prop5: 123,
-})
-    .set({ attr6: 456 })
-    .go({ response: "all_new" })
-    .then((results) => {
-    (0, tsd_1.expectType)(magnify(results.data));
-});
-//# sourceMappingURL=index.test-d.js.map