electrodb 3.6.1 → 3.6.2

package/dist/index.test-d.js

@@ -0,0 +1,4043 @@
+"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