From 1446a811e2a891bd2a68c6b1aa26aa63404ebbf0 Mon Sep 17 00:00:00 2001
From: Long Tran <mail@tranhl.me>
Date: Sat, 3 Feb 2024 16:00:05 +1100
Subject: [PATCH] feat: strongly typed item methods

---
 packages/dynamoose/lib/General.ts             | 12 +--
 packages/dynamoose/lib/Item.ts                |  8 ++
 packages/dynamoose/lib/Model/index.ts         | 90 +++++++++----------
 packages/dynamoose/lib/ModelStore.ts          |  6 +-
 packages/dynamoose/lib/Schema.ts              |  6 +-
 packages/dynamoose/lib/Serializer.ts          |  6 +-
 packages/dynamoose/lib/index.ts               | 10 +--
 .../lib/utils/dynamoose/returnModel.ts        |  4 +-
 packages/dynamoose/test/types/Item.ts         |  6 +-
 packages/dynamoose/test/types/Model.ts        | 15 +++-
 packages/dynamoose/test/types/model/Query.ts  |  8 +-
 packages/dynamoose/test/types/model/Scan.ts   |  8 +-
 12 files changed, 100 insertions(+), 79 deletions(-)

diff --git a/packages/dynamoose/lib/General.ts b/packages/dynamoose/lib/General.ts
index 2d27ae933..354dffa95 100644
--- a/packages/dynamoose/lib/General.ts
+++ b/packages/dynamoose/lib/General.ts
@@ -1,4 +1,4 @@
-import {Item} from "./Item";
+import {Item, ItemMethods} from "./Item";
 import {Model} from "./Model";
 
 // - General
@@ -14,7 +14,9 @@ export type KeyObject = {[attribute: string]: string | number};
 // An item representing a DynamoDB key
 export type InputKey = string | number | KeyObject;
 
-interface ModelItemConstructor<T extends Item> {
+type Expand<T> = {[KeyType in keyof T]: T[KeyType]} & {};
+
+interface ModelItemConstructor<T extends Item, U extends ItemMethods> {
 	/**
 	 * In order to create a new item you just pass in your object into an instance of your model.
 	 *
@@ -29,10 +31,10 @@ interface ModelItemConstructor<T extends Item> {
 	 * // myUser is now an item instance of the User model
 	 * ```
 	 */
-	new (object: {[key: string]: any}): T;
-	Model: Model<T>;
+	new (object: Expand<Omit<T, keyof Item>>): T & U;
+	Model: Model<T, U>;
 }
-export type ModelType<T extends Item> = T & Model<T> & ModelItemConstructor<T>;
+export type ModelType<T extends Item, U extends ItemMethods> = T & Model<T, U> & ModelItemConstructor<T, U>;
 
 // This represents an item array. This is used for the output of functions such as `scan`, `query`, and `batchGet`. These functions can extend this property to add additional properties or functions. However this represents the shared properties/functions for all item arrays.
 export interface ItemArray<T> extends Array<T> {
diff --git a/packages/dynamoose/lib/Item.ts b/packages/dynamoose/lib/Item.ts
index 4d5396411..5587939d4 100644
--- a/packages/dynamoose/lib/Item.ts
+++ b/packages/dynamoose/lib/Item.ts
@@ -30,6 +30,14 @@ export interface ItemSettings {
 	type?: "fromDynamo" | "toDynamo";
 }
 
+export interface ItemMethods {
+	[key: string]: Function;
+}
+
+export interface AnyItemMethods {
+	[key: string]: any;
+}
+
 interface ItemInternalProperties {
 	originalObject: any;
 	originalSettings: ItemSettings;
diff --git a/packages/dynamoose/lib/Model/index.ts b/packages/dynamoose/lib/Model/index.ts
index a0172c5aa..671f49da6 100644
--- a/packages/dynamoose/lib/Model/index.ts
+++ b/packages/dynamoose/lib/Model/index.ts
@@ -1,7 +1,7 @@
 import CustomError from "../Error";
 import ModelStore from "../ModelStore";
 import {Schema, SchemaDefinition, DynamoDBSetTypeResult, ValueType, IndexItem, TableIndex} from "../Schema";
-import {Item as ItemCarrier, ItemSaveSettings, ItemSettings, ItemObjectFromSchemaSettings, AnyItem} from "../Item";
+import {Item as ItemCarrier, ItemSaveSettings, ItemSettings, ItemObjectFromSchemaSettings, AnyItem, ItemMethods, AnyItemMethods} from "../Item";
 import utils from "../utils";
 import ddb from "../aws/ddb/internal";
 import Internal from "../Internal";
@@ -131,7 +131,7 @@ interface ModelInternalProperties {
 }
 
 // Model represents a single entity (ex. User, Movie, Video, Order)
-export class Model<T extends ItemCarrier = AnyItem> extends InternalPropertiesClass<ModelInternalProperties> {
+export class Model<T extends ItemCarrier = AnyItem, U extends ItemMethods = AnyItemMethods> extends InternalPropertiesClass<ModelInternalProperties> {
 	/**
 	 * This method is the basic entry point for creating a model in Dynamoose. When you call this method a new model is created, and it returns an item initializer that you can use to create instances of the given model.
 	 *
@@ -153,14 +153,14 @@ export class Model<T extends ItemCarrier = AnyItem> extends InternalPropertiesCl
 	 * const Cat = dynamoose.model("Cat", new dynamoose.Schema({"name": String}));
 	 * ```
 	 *
-	 * An optional TypeScript class which extends `Item` can be provided right before the function bracket. This provides type checking when using operations like `Model.create()`.
+	 * An optional TypeScript type which extends `Item` can be provided as a generic to `dynamoose.model`. This provides type checking when using operations like `Model.create()`.
 	 *
 	 * ```ts
 	 * import * as dynamoose from "dynamoose";
 	 * import {Item} from "dynamoose/dist/Item";
 	 *
 	 * // Strongly typed model
-	 * class Cat extends Item {
+	 * interface Cat extends Item {
 	 * 	id: number;
 	 * 	name: string;
 	 * }
@@ -439,21 +439,21 @@ export class Model<T extends ItemCarrier = AnyItem> extends InternalPropertiesCl
 	// latestTableDetails: DynamoDB.DescribeTableOutput;
 	// pendingTaskPromise: () => Promise<void>;
 	Item: typeof ItemCarrier;
-	scan: (object?: ConditionInitializer) => Scan<T>;
-	query: (object?: ConditionInitializer) => Query<T>;
+	scan: (object?: ConditionInitializer) => Scan<T & U>;
+	query: (object?: ConditionInitializer) => Query<T & U>;
 	methods: { item: { set: (name: string, fn: FunctionType) => void; delete: (name: string) => void }; set: (name: string, fn: FunctionType) => void; delete: (name: string) => void };
 	transaction: TransactionType;
 
 	// Batch Get
-	batchGet (keys: InputKey[]): Promise<ModelBatchGetItemsResponse<T>>;
-	batchGet (keys: InputKey[], callback: CallbackType<ModelBatchGetItemsResponse<T>, any>): void;
+	batchGet (keys: InputKey[]): Promise<ModelBatchGetItemsResponse<T & U>>;
+	batchGet (keys: InputKey[], callback: CallbackType<ModelBatchGetItemsResponse<T & U>, any>): void;
 	batchGet (keys: InputKey[], settings: ModelBatchGetSettings & {"return": "request"}): Promise<DynamoDB.BatchGetItemInput>;
 	batchGet (keys: InputKey[], settings: ModelBatchGetSettings & {"return": "request"}, callback: CallbackType<DynamoDB.BatchGetItemInput, any>): void;
-	batchGet (keys: InputKey[], settings: ModelBatchGetSettings): Promise<ModelBatchGetItemsResponse<T>>;
-	batchGet (keys: InputKey[], settings: ModelBatchGetSettings, callback: CallbackType<ModelBatchGetItemsResponse<T>, any>): void;
-	batchGet (keys: InputKey[], settings: ModelBatchGetSettings & {"return": "items"}): Promise<ModelBatchGetItemsResponse<T>>;
-	batchGet (keys: InputKey[], settings: ModelBatchGetSettings & {"return": "items"}, callback: CallbackType<ModelBatchGetItemsResponse<T>, any>): void;
-	batchGet (keys: InputKey[], settings?: ModelBatchGetSettings | CallbackType<ModelBatchGetItemsResponse<T>, any> | CallbackType<DynamoDB.BatchGetItemInput, any>, callback?: CallbackType<ModelBatchGetItemsResponse<T>, any> | CallbackType<DynamoDB.BatchGetItemInput, any>): void | Promise<DynamoDB.BatchGetItemInput> | Promise<ModelBatchGetItemsResponse<T>> {
+	batchGet (keys: InputKey[], settings: ModelBatchGetSettings): Promise<ModelBatchGetItemsResponse<T & U>>;
+	batchGet (keys: InputKey[], settings: ModelBatchGetSettings, callback: CallbackType<ModelBatchGetItemsResponse<T & U>, any>): void;
+	batchGet (keys: InputKey[], settings: ModelBatchGetSettings & {"return": "items"}): Promise<ModelBatchGetItemsResponse<T & U>>;
+	batchGet (keys: InputKey[], settings: ModelBatchGetSettings & {"return": "items"}, callback: CallbackType<ModelBatchGetItemsResponse<T & U>, any>): void;
+	batchGet (keys: InputKey[], settings?: ModelBatchGetSettings | CallbackType<ModelBatchGetItemsResponse<T & U>, any> | CallbackType<DynamoDB.BatchGetItemInput, any>, callback?: CallbackType<ModelBatchGetItemsResponse<T & U>, any> | CallbackType<DynamoDB.BatchGetItemInput, any>): void | Promise<DynamoDB.BatchGetItemInput> | Promise<ModelBatchGetItemsResponse<T & U>> {
 		if (typeof settings === "function") {
 			callback = settings;
 			settings = {"return": "items"};
@@ -528,9 +528,9 @@ export class Model<T extends ItemCarrier = AnyItem> extends InternalPropertiesCl
 			const localCallback: CallbackType<ItemCarrier[], any> = callback as CallbackType<ItemCarrier[], any>;
 			promise.then((response) => prepareResponse(response)).then((response) => localCallback(null, response)).catch((error) => localCallback(error));
 		} else {
-			return (async (): Promise<ModelBatchGetItemsResponse<T>> => {
+			return (async (): Promise<ModelBatchGetItemsResponse<T & U>> => {
 				const response = await promise;
-				return prepareResponse(response) as Promise<ModelBatchGetItemsResponse<T>>;
+				return prepareResponse(response) as Promise<ModelBatchGetItemsResponse<T & U>>;
 			})();
 		}
 	}
@@ -667,25 +667,25 @@ export class Model<T extends ItemCarrier = AnyItem> extends InternalPropertiesCl
 	}
 
 	// Update
-	update (obj: UpdatePartial<T>): Promise<T>;
-	update (obj: UpdatePartial<T>, callback: CallbackType<T, any>): void;
-	update (keyObj: InputKey, updateObj: UpdatePartial<T>): Promise<T>;
-	update (keyObj: InputKey, updateObj: UpdatePartial<T>, callback: CallbackType<T, any>): void;
+	update (obj: UpdatePartial<T>): Promise<T & U>;
+	update (obj: UpdatePartial<T>, callback: CallbackType<T & U, any>): void;
+	update (keyObj: InputKey, updateObj: UpdatePartial<T>): Promise<T & U>;
+	update (keyObj: InputKey, updateObj: UpdatePartial<T>, callback: CallbackType<T & U, any>): void;
 	update (keyObj: InputKey, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings & {"return": "request"}): Promise<DynamoDB.UpdateItemInput>;
 	update (keyObj: InputKey, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings & {"return": "request"}, callback: CallbackType<DynamoDB.UpdateItemInput, any>): void;
-	update (keyObj: InputKey, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings): Promise<T>;
-	update (keyObj: InputKey, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings, callback: CallbackType<T, any>): void;
-	update (keyObj: InputKey, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings & {"return": "document"}): Promise<T>;
-	update (keyObj: InputKey, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings & {"return": "document"}, callback: CallbackType<T, any>): void;
-	update (keyObj: ObjectType, updateObj: UpdatePartial<T>): Promise<T>;
-	update (keyObj: ObjectType, updateObj: UpdatePartial<T>, callback: CallbackType<T, any>): void;
+	update (keyObj: InputKey, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings): Promise<T & U>;
+	update (keyObj: InputKey, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings, callback: CallbackType<T & U, any>): void;
+	update (keyObj: InputKey, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings & {"return": "document"}): Promise<T & U>;
+	update (keyObj: InputKey, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings & {"return": "document"}, callback: CallbackType<T & U, any>): void;
+	update (keyObj: ObjectType, updateObj: UpdatePartial<T>): Promise<T & U>;
+	update (keyObj: ObjectType, updateObj: UpdatePartial<T>, callback: CallbackType<T & U, any>): void;
 	update (keyObj: ObjectType, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings & {"return": "request"}): Promise<DynamoDB.UpdateItemInput>;
 	update (keyObj: ObjectType, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings & {"return": "request"}, callback: CallbackType<DynamoDB.UpdateItemInput, any>): void;
-	update (keyObj: ObjectType, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings): Promise<T>;
-	update (keyObj: ObjectType, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings, callback: CallbackType<T, any>): void;
-	update (keyObj: ObjectType, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings & {"return": "item"}): Promise<T>;
-	update (keyObj: ObjectType, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings & {"return": "item"}, callback: CallbackType<T, any>): void;
-	update (keyObj: InputKey | ObjectType, updateObj?: UpdatePartial<T> | CallbackType<T, any> | CallbackType<DynamoDB.UpdateItemInput, any>, settings?: ModelUpdateSettings | CallbackType<T, any> | CallbackType<DynamoDB.UpdateItemInput, any>, callback?: CallbackType<T, any> | CallbackType<DynamoDB.UpdateItemInput, any>): void | Promise<T> | Promise<DynamoDB.UpdateItemInput> {
+	update (keyObj: ObjectType, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings): Promise<T & U>;
+	update (keyObj: ObjectType, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings, callback: CallbackType<T & U, any>): void;
+	update (keyObj: ObjectType, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings & {"return": "item"}): Promise<T & U>;
+	update (keyObj: ObjectType, updateObj: UpdatePartial<T>, settings: ModelUpdateSettings & {"return": "item"}, callback: CallbackType<T & U, any>): void;
+	update (keyObj: InputKey | ObjectType, updateObj?: UpdatePartial<T> | CallbackType<T & U, any> | CallbackType<DynamoDB.UpdateItemInput, any>, settings?: ModelUpdateSettings | CallbackType<T & U, any> | CallbackType<DynamoDB.UpdateItemInput, any>, callback?: CallbackType<T & U, any> | CallbackType<DynamoDB.UpdateItemInput, any>): void | Promise<T & U> | Promise<DynamoDB.UpdateItemInput> {
 		if (typeof updateObj === "function") {
 			callback = updateObj as CallbackType<ItemCarrier | DynamoDB.UpdateItemInput, any>; // TODO: fix this, for some reason `updateObj` has a type of Function which is forcing us to type cast it
 			updateObj = null;
@@ -924,15 +924,15 @@ export class Model<T extends ItemCarrier = AnyItem> extends InternalPropertiesCl
 	}
 
 	// Create
-	create (item: Partial<T>): Promise<T>;
-	create (item: Partial<T>, callback: CallbackType<T, any>): void;
+	create (item: Partial<T>): Promise<T & U>;
+	create (item: Partial<T>, callback: CallbackType<T & U, any>): void;
 	create (item: Partial<T>, settings: ItemSaveSettings & {return: "request"}): Promise<DynamoDB.PutItemInput>;
 	create (item: Partial<T>, settings: ItemSaveSettings & {return: "request"}, callback: CallbackType<DynamoDB.PutItemInput, any>): void;
-	create (item: Partial<T>, settings: ItemSaveSettings): Promise<T>;
-	create (item: Partial<T>, settings: ItemSaveSettings, callback: CallbackType<T, any>): void;
-	create (item: Partial<T>, settings: ItemSaveSettings & {return: "item"}): Promise<T>;
-	create (item: Partial<T>, settings: ItemSaveSettings & {return: "item"}, callback: CallbackType<T, any>): void;
-	create (item: Partial<T>, settings?: ItemSaveSettings | CallbackType<T, any> | CallbackType<DynamoDB.PutItemInput, any>, callback?: CallbackType<T, any> | CallbackType<DynamoDB.PutItemInput, any>): void | Promise<T> | Promise<DynamoDB.PutItemInput> {
+	create (item: Partial<T>, settings: ItemSaveSettings): Promise<T & U>;
+	create (item: Partial<T>, settings: ItemSaveSettings, callback: CallbackType<T & U, any>): void;
+	create (item: Partial<T>, settings: ItemSaveSettings & {return: "item"}): Promise<T & U>;
+	create (item: Partial<T>, settings: ItemSaveSettings & {return: "item"}, callback: CallbackType<T & U, any>): void;
+	create (item: Partial<T>, settings?: ItemSaveSettings | CallbackType<T & U, any> | CallbackType<DynamoDB.PutItemInput, any>, callback?: CallbackType<T & U, any> | CallbackType<DynamoDB.PutItemInput, any>): void | Promise<T & U> | Promise<DynamoDB.PutItemInput> {
 		if (typeof settings === "function" && !callback) {
 			callback = settings;
 			settings = {};
@@ -1004,15 +1004,15 @@ export class Model<T extends ItemCarrier = AnyItem> extends InternalPropertiesCl
 	}
 
 	// Get
-	get (key: InputKey): Promise<T>;
-	get (key: InputKey, callback: CallbackType<T, any>): void;
+	get (key: InputKey): Promise<T & U>;
+	get (key: InputKey, callback: CallbackType<T & U, any>): void;
 	get (key: InputKey, settings: ModelGetSettings & {return: "request"}): Promise<DynamoDB.GetItemInput>;
 	get (key: InputKey, settings: ModelGetSettings & {return: "request"}, callback: CallbackType<DynamoDB.GetItemInput, any>): void;
-	get (key: InputKey, settings: ModelGetSettings): Promise<T>;
-	get (key: InputKey, settings: ModelGetSettings, callback: CallbackType<T, any>): void;
-	get (key: InputKey, settings: ModelGetSettings & {return: "item"}): Promise<T>;
-	get (key: InputKey, settings: ModelGetSettings & {return: "item"}, callback: CallbackType<T, any>): void;
-	get (key: InputKey, settings?: ModelGetSettings | CallbackType<T, any> | CallbackType<DynamoDB.GetItemInput, any>, callback?: CallbackType<T, any> | CallbackType<DynamoDB.GetItemInput, any>): void | Promise<DynamoDB.GetItemInput> | Promise<T> {
+	get (key: InputKey, settings: ModelGetSettings): Promise<T & U>;
+	get (key: InputKey, settings: ModelGetSettings, callback: CallbackType<T & U, any>): void;
+	get (key: InputKey, settings: ModelGetSettings & {return: "item"}): Promise<T & U>;
+	get (key: InputKey, settings: ModelGetSettings & {return: "item"}, callback: CallbackType<T & U, any>): void;
+	get (key: InputKey, settings?: ModelGetSettings | CallbackType<T & U, any> | CallbackType<DynamoDB.GetItemInput, any>, callback?: CallbackType<T & U, any> | CallbackType<DynamoDB.GetItemInput, any>): void | Promise<DynamoDB.GetItemInput> | Promise<T & U> {
 		if (typeof settings === "function") {
 			callback = settings;
 			settings = {"return": "item"};
@@ -1070,7 +1070,7 @@ export class Model<T extends ItemCarrier = AnyItem> extends InternalPropertiesCl
 	}
 
 	// Serialize Many
-	serializeMany (itemsArray: ModelType<ItemCarrier>[] = [], nameOrOptions: SerializerOptions | string): any {
+	serializeMany (itemsArray: ModelType<ItemCarrier, U>[] = [], nameOrOptions: SerializerOptions | string): any {
 		return this.serializer.getInternalProperties(internalProperties).serializeMany(itemsArray, nameOrOptions);
 	}
 }
diff --git a/packages/dynamoose/lib/ModelStore.ts b/packages/dynamoose/lib/ModelStore.ts
index bb4e1e736..9b71905c5 100644
--- a/packages/dynamoose/lib/ModelStore.ts
+++ b/packages/dynamoose/lib/ModelStore.ts
@@ -1,17 +1,17 @@
 import CustomError from "./Error";
 import {Model} from "./Model";
-import {Item} from "./Item";
+import {Item, ItemMethods} from "./Item";
 import Internal from "./Internal";
 const {internalProperties} = Internal.General;
 
 let models: {[name: string]: Model<Item>} = {};
 
-const returnObject = <T extends Item>(input: Model<T> | string): Model<T> | never => {
+const returnObject = <T extends Item, U extends ItemMethods>(input: Model<T, U> | string): Model<T, U> | never => {
 	if (input instanceof Model) {
 		models[input.name] = input;
 		return input;
 	} else if (typeof input === "string") {
-		return models[input] as Model<T>;
+		return models[input] as Model<T, U>;
 	} else {
 		throw new CustomError.InvalidParameter("You must pass in a Model or model name as a string.");
 	}
diff --git a/packages/dynamoose/lib/Schema.ts b/packages/dynamoose/lib/Schema.ts
index a3e843de5..3d4a56c56 100644
--- a/packages/dynamoose/lib/Schema.ts
+++ b/packages/dynamoose/lib/Schema.ts
@@ -1,7 +1,7 @@
 import CustomError from "./Error";
 import utils from "./utils";
 import Internal from "./Internal";
-import {Item, ItemObjectFromSchemaSettings} from "./Item";
+import {AnyItemMethods, Item, ItemObjectFromSchemaSettings} from "./Item";
 import {Model, ModelIndexes} from "./Model";
 import * as DynamoDB from "@aws-sdk/client-dynamodb";
 import {ModelType, ObjectType} from "./General";
@@ -273,7 +273,7 @@ const attributeTypes: (DynamoDBTypeResult | DynamoDBSetTypeResult)[] = utils.arr
 
 type GeneralValueType = string | boolean | number | Buffer | Date;
 export type ValueType = GeneralValueType | {[key: string]: ValueType} | ValueType[];
-type AttributeType = string | StringConstructor | BooleanConstructor | NumberConstructor | typeof Buffer | DateConstructor | ObjectConstructor | ArrayConstructor | SetConstructor | symbol | Schema | ModelType<Item>;
+type AttributeType = string | StringConstructor | BooleanConstructor | NumberConstructor | typeof Buffer | DateConstructor | ObjectConstructor | ArrayConstructor | SetConstructor | symbol | Schema | ModelType<Item, AnyItemMethods>;
 
 export interface TimestampObject {
 	createdAt?: string | string[] | SchemaDefinition;
@@ -324,7 +324,7 @@ interface IndexDefinition {
 }
 interface AttributeDefinitionTypeSettings {
 	storage?: "milliseconds" | "seconds" | "iso";
-	model?: ModelType<Item>;
+	model?: ModelType<Item, AnyItemMethods>;
 	attributes?: string[];
 	separator?: string;
 	value?: string | boolean | number;
diff --git a/packages/dynamoose/lib/Serializer.ts b/packages/dynamoose/lib/Serializer.ts
index a915a4eb4..18165d0f6 100644
--- a/packages/dynamoose/lib/Serializer.ts
+++ b/packages/dynamoose/lib/Serializer.ts
@@ -1,5 +1,5 @@
 import {ObjectType, ModelType} from "./General";
-import {Item} from "./Item";
+import {AnyItemMethods, Item} from "./Item";
 import CustomError from "./Error";
 import utils from "./utils";
 import {InternalPropertiesClass} from "./InternalPropertiesClass";
@@ -16,7 +16,7 @@ interface SerializerInternalProperties {
 	serializers: {[key: string]: SerializerOptions};
 	defaultSerializer?: string;
 
-	serializeMany: (itemsArray: ModelType<Item>[], nameOrOptions: SerializerOptions | string) => ObjectType[];
+	serializeMany: (itemsArray: ModelType<Item, AnyItemMethods>[], nameOrOptions: SerializerOptions | string) => ObjectType[];
 	serialize: (item: ObjectType, nameOrOptions: SerializerOptions | string) => ObjectType;
 }
 
@@ -32,7 +32,7 @@ export class Serializer extends InternalPropertiesClass<SerializerInternalProper
 					"modify": (serialized: ObjectType, original: ObjectType): ObjectType => ({...original})
 				}
 			},
-			"serializeMany": (itemsArray: ModelType<Item>[], nameOrOptions: SerializerOptions | string): ObjectType[] => {
+			"serializeMany": (itemsArray: ModelType<Item, AnyItemMethods>[], nameOrOptions: SerializerOptions | string): ObjectType[] => {
 				if (!itemsArray || !Array.isArray(itemsArray)) {
 					throw new CustomError.InvalidParameter("itemsArray must be an array of item objects");
 				}
diff --git a/packages/dynamoose/lib/index.ts b/packages/dynamoose/lib/index.ts
index 79d4916f5..5c0014ee3 100644
--- a/packages/dynamoose/lib/index.ts
+++ b/packages/dynamoose/lib/index.ts
@@ -3,7 +3,7 @@ import {Schema, SchemaDefinition} from "./Schema";
 import {Condition} from "./Condition";
 import transaction from "./Transaction";
 import utils from "./utils";
-import {Item, AnyItem} from "./Item";
+import {Item, AnyItem, ItemMethods, AnyItemMethods} from "./Item";
 import ModelStore from "./ModelStore";
 import {ModelType} from "./General";
 import CustomError from "./Error";
@@ -13,11 +13,11 @@ import {Instance} from "./Instance";
 import {custom as TableDefaults} from "./Table/defaults";
 import returnModel from "./utils/dynamoose/returnModel";
 
-const model = <T extends Item = AnyItem>(name: string, schema?: Schema | SchemaDefinition | (Schema | SchemaDefinition)[], options?: ModelTableOptions): ModelType<T> => {
-	let model: Model<T>;
-	let storedSchema: Model<T>;
+const model = <T extends Item = AnyItem, U extends ItemMethods = AnyItemMethods>(name: string, schema?: Schema | SchemaDefinition | (Schema | SchemaDefinition)[], options?: ModelTableOptions): ModelType<T, U> => {
+	let model: Model<T, U>;
+	let storedSchema: Model<T, U>;
 	if (name) {
-		storedSchema = ModelStore<T>(name);
+		storedSchema = ModelStore<T, U>(name);
 	}
 	// TODO: this is something I'd like to do. But is a breaking change. Need to enable this and uncomment it in a breaking release. Also will need to fix the tests as well.
 	/* if (schema && storedSchema) {
diff --git a/packages/dynamoose/lib/utils/dynamoose/returnModel.ts b/packages/dynamoose/lib/utils/dynamoose/returnModel.ts
index a4c9f5636..77613483e 100644
--- a/packages/dynamoose/lib/utils/dynamoose/returnModel.ts
+++ b/packages/dynamoose/lib/utils/dynamoose/returnModel.ts
@@ -1,9 +1,9 @@
 import utils from "..";
 import {ModelType} from "../../General";
-import {AnyItem, Item} from "../../Item";
+import {AnyItem, AnyItemMethods, Item, ItemMethods} from "../../Item";
 import {Model} from "../../Model";
 
-export default <T extends Item = AnyItem>(model: Model<T>): ModelType<T> => {
+export default <T extends Item = AnyItem, U extends ItemMethods = AnyItemMethods>(model: Model<T>): ModelType<T, U> => {
 	const returnObject: any = model.Item;
 	const keys = utils.array_flatten([
 		Object.keys(model),
diff --git a/packages/dynamoose/test/types/Item.ts b/packages/dynamoose/test/types/Item.ts
index ec1953abb..0f8dfefa1 100644
--- a/packages/dynamoose/test/types/Item.ts
+++ b/packages/dynamoose/test/types/Item.ts
@@ -1,6 +1,6 @@
-import {User, UserTypedModel} from "./Model";
+import {UserTypedModel} from "./Model";
 
-const user = new User(UserTypedModel, {"id": "1", "name": "Jane", "age": 30});
+const user = new UserTypedModel({"id": "1", "name": "Jane", "age": 30});
 
 const shouldPassSave = user.save();
 const shouldPassSaveWithReturnRequest = user.save({"return": "request"});
@@ -11,3 +11,5 @@ const shouldPassSaveWithReturnItemCallback = user.save({"return": "item"}, () =>
 
 // @ts-expect-error
 const shouldFailWithInvalidReturnType = user.save({"return": "invalid-return-type"});
+
+const shouldPassCustomMethodAccess = user.resetPassword();
diff --git a/packages/dynamoose/test/types/Model.ts b/packages/dynamoose/test/types/Model.ts
index c17536661..17099d799 100644
--- a/packages/dynamoose/test/types/Model.ts
+++ b/packages/dynamoose/test/types/Model.ts
@@ -1,7 +1,7 @@
 /* eslint @typescript-eslint/no-unused-vars: 0 */
 
 import * as dynamoose from "../../dist";
-import {Item} from "../../dist/Item";
+import {Item, ItemMethods} from "../../dist/Item";
 import {IndexType} from "../../dist/Schema";
 
 // @ts-expect-error
@@ -73,11 +73,17 @@ const shouldFailWithInvalidUpdateTransaction = model.transaction.update(0);
 const shouldFailWithInvalidConditionTransaction = model.transaction.condition(0, []);
 
 // Typed Models
-export class User extends Item {
+
+export interface UserMethods extends ItemMethods {
+	resetPassword: () => Promise<void>;
+}
+
+export interface UserItem extends Item {
 	id: string;
 	name: string;
 	age: number;
 }
+
 const userSchema = new dynamoose.Schema({
 	"id": String,
 	"name": {
@@ -89,7 +95,7 @@ const userSchema = new dynamoose.Schema({
 	"age": Number
 });
 
-export const UserTypedModel = dynamoose.model<User>(
+export const UserTypedModel = dynamoose.model<UserItem, UserMethods>(
 	"User",
 	userSchema
 );
@@ -110,3 +116,6 @@ UserTypedModel.update({"id": "foo"}, {
 UserTypedModel.update({"id": "foo"}, {
 	"$REMOVE":{"age":null}
 });
+
+// @ts-expect-error
+const shouldFailItemCustomMethodAccess = UserTypedModel.resetPassword();
diff --git a/packages/dynamoose/test/types/model/Query.ts b/packages/dynamoose/test/types/model/Query.ts
index b686e0fab..103afa29c 100644
--- a/packages/dynamoose/test/types/model/Query.ts
+++ b/packages/dynamoose/test/types/model/Query.ts
@@ -1,13 +1,13 @@
 /* eslint @typescript-eslint/no-unused-vars: 0, no-console: 0 */
 
-import {UserTypedModel, UserModel, User} from "../Model";
+import {UserTypedModel, UserModel, User, UserMethods} from "../Model";
 import {ObjectType, SortOrder} from "../../../dist/General";
 import {Condition} from "../../../dist";
 import {AnyItem} from "../../../dist/Item";
 import {QueryResponse, Query} from "../../../dist/ItemRetriever";
 
 // query.exec([callback])
-async function queryExec (): Promise<User[]> {
+async function queryExec (): Promise<Array<User & UserMethods>> {
 	return await UserTypedModel.query().exec();
 }
 async function queryExecUnTyped (): Promise<AnyItem[]> {
@@ -15,9 +15,9 @@ async function queryExecUnTyped (): Promise<AnyItem[]> {
 }
 
 const queryExecUnTypedQueryResponse: Promise<QueryResponse<AnyItem>> = UserModel.query().exec();
-const queryExecTyped: Promise<QueryResponse<User>> = UserTypedModel.query("name").eq("Will").exec();
+const queryExecTyped: Promise<QueryResponse<User & UserMethods>> = UserTypedModel.query("name").eq("Will").exec();
 
-let isAssignableToQuery : Query<User>;
+let isAssignableToQuery : Query<User & UserMethods>;
 
 // query.limit(count)
 isAssignableToQuery = UserTypedModel.query("name").eq("Will").limit(5);
diff --git a/packages/dynamoose/test/types/model/Scan.ts b/packages/dynamoose/test/types/model/Scan.ts
index b76dd836a..1d314c357 100644
--- a/packages/dynamoose/test/types/model/Scan.ts
+++ b/packages/dynamoose/test/types/model/Scan.ts
@@ -1,13 +1,13 @@
 /* eslint @typescript-eslint/no-unused-vars: 0, no-console: 0 */
 
-import {UserTypedModel, User, UserModel} from "../Model";
+import {UserTypedModel, User, UserModel, UserMethods} from "../Model";
 import {Condition} from "../../../dist";
 import {AnyItem} from "../../../dist/Item";
 import {ScanResponse, Scan} from "../../../dist/ItemRetriever";
 import {ObjectType} from "../../../dist/General";
 
 // scan.exec([callback])
-async function scanExec (): Promise<User[]> {
+async function scanExec (): Promise<Array<User & UserMethods>> {
 	return await UserTypedModel.scan().exec();
 }
 async function scanExecUnTyped (): Promise<AnyItem[]> {
@@ -15,11 +15,11 @@ async function scanExecUnTyped (): Promise<AnyItem[]> {
 }
 
 const scanExecUnTypedWithScanResponse: Promise<ScanResponse<AnyItem>> = UserModel.scan().exec();
-const scanExecTyped: Promise<ScanResponse<User>> = UserTypedModel.scan("name").eq("Will").exec();
+const scanExecTyped: Promise<ScanResponse<User & UserMethods>> = UserTypedModel.scan("name").eq("Will").exec();
 
 UserTypedModel.scan().exec();
 
-let isAssignableToScan : Scan<User>;
+let isAssignableToScan : Scan<User & UserMethods>;
 
 // scan.limit(count)
 isAssignableToScan = UserTypedModel.scan().limit(5);