Error in `parseModel` -> `normalize indexes` about electrodb HOT 8 CLOSED

export const buildPartitionKey = (docmailMailingGuid: string): string => `${MAILING_PREFIX}${docmailMailingGuid}`;
export const buildSortKey = (): string => `${MAILING_PREFIX}`;
export const buildGsi1PartitionKey = (policyId: string): string => `${POLICY_PREFIX}${policyId}`;
export const buildGsi1SortKey = (effectiveDate: string): string => `${EFFECTIVE_DATE_PREFIX}${effectiveDate}`;
export const buildGsi2PartitionKey = (requestedAt: string): string => `${REQUESTED_AT_PREFIX}${requestedAt}`;
export const buildGsi2SortKey = (): string => `${REQUESTED_AT_PREFIX}`;

export const documentPrintRequest = new Entity(
  {
    model: {
      entity: "document print requests",
      version: "1",
      service: "docmail"
    },
    attributes: {
      partitionKey: {
        type: "string",
        required: true,
        readOnly: true
      },
      sortKey: {
        type: "string",
        required: true,
        readOnly: true,
        default: MAILING_PREFIX
      },
      gsi1PartitionKey: {
        type: "string",
        required: true,
        readOnly: true
      },
      gsi1SortKey: {
        type: "string",
        required: true,
        readOnly: true,
      },
      gsi2PartitionKey: {
        type: "string",
        required: true,
        readOnly: true
      },
      gsi2SortKey: {
        type: "string",
        required: true,
        readOnly: true,
        default: REQUESTED_AT_PREFIX
      },
      policyId: {
        type: "string",
        required: true
      },
      effectiveDate: {
        type: "string",
        required: true
      },
      docmailMailingGuid: {
        type: "string",
        required: true
      },
      requestedAt: {
        type: "string",
        required: true
      },
    },
    indexes: {
      byDocmailMailingGuid: {
        pk: {
          field: "partitionKey",
          composite: ["docmailMailingGuid"],
          casing: "none",
          template: buildPartitionKey("${docmailMailingGuid}")
        },
        sk: {
          field: "sortKey",
          composite: [],
          casing: "none",
          template: buildSortKey()
        }
      },
      byPolicyIdAndEffectiveDate: {
        index: "gsi1",
        pk: {
          field: "gsi1PartitionKey",
          composite: ["policyId"],
          template: buildGsi1PartitionKey("${policyId}"),
          casing: "none"
        },
        sk: {
          field: "gsi1SortKey",
          composite: ["effectiveDate"],
          template: buildGsi1SortKey("${effectiveDate}"),
          casing: "none"
        }
      },
      byRequestedAtDate: {
        index: "gsi2",
        pk: {
          field: "gsi2PartitionKey",
          composite: ["requestedAt"],
          template: buildGsi2PartitionKey("${requestedAt}"),
          casing: "none"
        },
        sk: {
          field: "gsi2SortKey",
          composite: [],
          template: buildGsi2SortKey(),
          casing: "none"
        }
      }
    }
  },
  {
    table: documentPrintRequestTableName,
    client: documentClient
  }
);```

error {
    "errorType": "ElectroValidationError",
    "errorMessage": "Invalid value type at entity path \"documentsRequested[*]. Received value of type \"unknown\", expected value of type \"object\", Invalid value type at entity path \"documentsRequested[*]. Received value of type \"unknown\", expected value of type \"object\", Invalid value type at entity path \"documentsRequested[*]. Received value of type \"unknown\", expected value of type \"object\" - For more detail on this error reference: https://github.com/tywalch/electrodb#invalid-attribute",
}

once again this doesn't occur in the electrodb playground, the only differences between the playground and our code being

1.) ours is running in an actual lambda
2.) our code is split across a few files

interface Array<T> {
  forEachAsync<T>(this: Array<T>, action: (value: T) => Promise<void>): Promise<void>;
  mapAsync<T, U>(this: Array<T>, map: (value: T) => Promise<U>): Promise<U[]>;
  removeNull(this: Array<T>): Array<NonNullable<T>>;
}

Array.prototype.forEachAsync = async function forEachAsync<T>(this: Array<T>, action: (value: T) => Promise<void>): Promise<void> {
  for (const element of this) {
    await action(element);
  }
};

Array.prototype.mapAsync = async function mapAsync<T, U>(this: Array<T>, mapFunction: (value: T) => Promise<U>): Promise<U[]> {
  const result: U[] = [];
  await this.forEachAsync(async (x) => {
    result.push(await mapFunction(x));
  });
  return result;
};

Array.prototype.removeNull = function removeNull<T>(this: Array<T>): Array<NonNullable<T>> {
  return this.filter((value): value is NonNullable<T> => value != null);
};