electrodb 1.9.0 → 1.10.2

package/index.d.ts

@@ -1,11 +1,532 @@
-type Flatten<T> = T extends any[]
-  ? T
-  : T extends object
-    ? {[Key in keyof T]: Flatten<T[Key]>}
-    : T;
+export type DocumentClientMethod = (parameters: any) => {promise: () => Promise<any>};
 
-declare const WhereSymbol: unique symbol;
-declare const UpdateDataSymbol: unique symbol;
+export type DocumentClient = {
+    get: DocumentClientMethod;
+    put: DocumentClientMethod;
+    delete: DocumentClientMethod;
+    update: DocumentClientMethod;
+    batchWrite: DocumentClientMethod;
+    batchGet: DocumentClientMethod;
+    scan: DocumentClientMethod;
+    transactGet: DocumentClientMethod;
+    transactWrite: DocumentClientMethod;
+} | {
+    send: (command: any) => Promise<any>;
+}
+
+export type AllCollectionNames<E extends {[name: string]: Entity<any, any, any, any>}> = {
+    [Name in keyof E]:
+    E[Name] extends Entity<infer A, infer F, infer C, infer S>
+        ? {
+            [Collection in keyof EntityCollections<A,F,C,S>]: Collection
+        }[keyof EntityCollections<A,F,C,S>]
+        : never
+}[keyof E];
+
+export type AllEntityAttributeNames<E extends {[name: string]: Entity<any, any, any, any>}> = {
+    [Name in keyof E]: {
+        [A in keyof E[Name]["schema"]["attributes"]]: A
+    }[keyof E[Name]["schema"]["attributes"]]
+}[keyof E];
+
+export type AllEntityAttributes<E extends {[name: string]: Entity<any, any, any, any>}> = {
+    [Attr in AllEntityAttributeNames<E>]: {
+        [Name in keyof E]: Attr extends keyof E[Name]["schema"]["attributes"]
+            ? ItemAttribute<E[Name]["schema"]["attributes"][Attr]>
+            : never
+    }[keyof E];
+};
+
+export type CollectionAssociations<E extends {[name: string]: Entity<any, any, any, any>}> = {
+    [Collection in AllCollectionNames<E>]: {
+        [Name in keyof E]: E[Name] extends Entity<infer A, infer F, infer C, infer S>
+            ? Collection extends keyof EntityCollections<A,F,C,S>
+                ? Name
+                : never
+            : never
+    }[keyof E];
+}
+
+export type CollectionAttributes<E extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<E>> = {
+    [Collection in keyof Collections]: {
+        [EntityName in keyof E]: E[EntityName] extends Entity<infer A, infer F, infer C, infer S>
+            ? EntityName extends Collections[Collection]
+                ? keyof S["attributes"]
+                : never
+            : never
+    }[keyof E]
+}
+
+export interface CollectionWhereOperations {
+    eq: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
+    ne: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
+    gt: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
+    lt: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
+    gte: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
+    lte: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
+    between: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T, value2: T) => string;
+    begins: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
+    exists: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
+    notExists: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
+    contains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
+    notContains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
+    value: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
+    name: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
+}
+
+export type CollectionWhereCallback<E extends {[name: string]: Entity<any, any, any, any>}, I extends Partial<AllEntityAttributes<E>>> =
+    <W extends {[A in keyof I]: WhereAttributeSymbol<I[A]>}>(attributes: W, operations: CollectionWhereOperations) => string;
+
+export type CollectionWhereClause<E extends {[name: string]: Entity<any, any, any, any>}, A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends Partial<AllEntityAttributes<E>>, T> = (where: CollectionWhereCallback<E, I>) => T;
+
+export interface WhereRecordsActionOptions<E extends {[name: string]: Entity<any, any, any, any>}, A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends Partial<AllEntityAttributes<E>>, Items, IndexCompositeAttributes> {
+    go: GoRecord<Items>;
+    params: ParamRecord;
+    page: PageRecord<Items,IndexCompositeAttributes>;
+    where: CollectionWhereClause<E,A,F,C,S,I, WhereRecordsActionOptions<E,A,F,C,S,I,Items,IndexCompositeAttributes>>;
+}
+
+export type CollectionIndexKeys<Entities extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<Entities>> = {
+    [Collection in keyof Collections]: {
+        [EntityResultName in Collections[Collection]]:
+        EntityResultName extends keyof Entities
+            ? Entities[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
+            ? keyof TableIndexCompositeAttributes<A, F, C, S>
+            : never
+            : never
+    }[Collections[Collection]]
+}
+
+export type CollectionPageKeys<Entities extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<Entities>> = {
+    [Collection in keyof Collections]: {
+        [EntityResultName in Collections[Collection]]:
+        EntityResultName extends keyof Entities
+            ? Entities[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
+            ? keyof Parameters<Entities[EntityResultName]["query"][
+                Collection extends keyof EntityCollections<A,F,C,S>
+                    ? EntityCollections<A,F,C,S>[Collection]
+                    : never
+                ]>[0]
+            : never
+            : never
+    }[Collections[Collection]]
+}
+
+export type CollectionIndexAttributes<Entities extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<Entities>> = {
+    [Collection in keyof CollectionIndexKeys<Entities, Collections>]: {
+        [key in CollectionIndexKeys<Entities, Collections>[Collection]]:
+        key extends keyof AllEntityAttributes<Entities>
+            ? AllEntityAttributes<Entities>[key]
+            : never
+    }
+}
+
+export type CollectionPageAttributes<Entities extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<Entities>> = {
+    [Collection in keyof CollectionPageKeys<Entities, Collections>]: {
+        [key in CollectionPageKeys<Entities, Collections>[Collection]]:
+        key extends keyof AllEntityAttributes<Entities>
+            ? AllEntityAttributes<Entities>[key]
+            : never
+    }
+}
+
+export type OptionalPropertyNames<T> =
+    { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T];
+
+// Common properties from L and R with undefined in R[K] replaced by type in L[K]
+export type SpreadProperties<L, R, K extends keyof L & keyof R> =
+    { [P in K]: L[P] | Exclude<R[P], undefined> };
+
+export type Id<T> = {[K in keyof T]: T[K]} // see note at bottom*
+
+// Type of { ...L, ...R }
+export type Spread<L, R> = Id<
+// Properties in L that don't exist in R
+    & Pick<L, Exclude<keyof L, keyof R>>
+// Properties in R with types that exclude undefined
+    & Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>>
+// Properties in R, with types that include undefined, that don't exist in L
+    & Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>>
+// Properties in R, with types that include undefined, that exist in L
+    & SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>
+    >;
+
+export type RequiredProperties<T> = Pick<T, {[K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T]>
+
+export type CollectionQueries<E extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<E>> = {
+    [Collection in keyof Collections]: {
+        [EntityName in keyof E]:
+        EntityName extends Collections[Collection]
+            ? (params:
+                   RequiredProperties<
+                       Parameters<
+                           E[EntityName]["query"][
+                               E[EntityName] extends Entity<infer A, infer F, infer C, infer S>
+                                   ? Collection extends keyof EntityCollections<A,F,C,S>
+                                   ? EntityCollections<A,F,C,S>[Collection]
+                                   : never
+                                   : never
+                               ]
+                           >[0]
+                       >) => {
+                go: GoRecord<{
+                    [EntityResultName in Collections[Collection]]:
+                    EntityResultName extends keyof E
+                        ? E[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
+                        ? ResponseItem<A,F,C,S>[]
+                        : never
+                        : never
+                }>;
+                params: ParamRecord;
+                page: {
+                    [EntityResultName in Collections[Collection]]: EntityResultName extends keyof E
+                        ? Pick<AllEntityAttributes<E>, Extract<AllEntityAttributeNames<E>, CollectionAttributes<E,Collections>[Collection]>> extends Partial<AllEntityAttributes<E>>
+                            ?
+                            PageRecord<
+                                {
+                                    [EntityResultName in Collections[Collection]]:
+                                    EntityResultName extends keyof E
+                                        ? E[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
+                                        ? ResponseItem<A,F,C,S>[]
+                                        : never
+                                        : never
+                                },
+                                Partial<
+                                    Spread<
+                                        Collection extends keyof CollectionPageAttributes<E, Collections>
+                                            ? CollectionPageAttributes<E, Collections>[Collection]
+                                            : {},
+                                        Collection extends keyof CollectionIndexAttributes<E, Collections>
+                                            ? CollectionIndexAttributes<E, Collections>[Collection]
+                                            : {}
+                                        >
+                                    >
+                                >
+                            : never
+                        : never
+                }[Collections[Collection]];
+                where: {
+                    [EntityResultName in Collections[Collection]]: EntityResultName extends keyof E
+                        ? E[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
+                            ? Pick<AllEntityAttributes<E>, Extract<AllEntityAttributeNames<E>, CollectionAttributes<E,Collections>[Collection]>> extends Partial<AllEntityAttributes<E>>
+                                ? CollectionWhereClause<E,A,F,C,S,
+                                    Pick<AllEntityAttributes<E>, Extract<AllEntityAttributeNames<E>, CollectionAttributes<E,Collections>[Collection]>>,
+                                    WhereRecordsActionOptions<E,A,F,C,S,
+                                        Pick<AllEntityAttributes<E>, Extract<AllEntityAttributeNames<E>, CollectionAttributes<E,Collections>[Collection]>>,
+                                        {
+                                            [EntityResultName in Collections[Collection]]:
+                                            EntityResultName extends keyof E
+                                                ? E[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
+                                                ? ResponseItem<A,F,C,S>[]
+                                                : never
+                                                : never
+                                        },
+                                        Partial<
+                                            Spread<
+                                                Collection extends keyof CollectionPageAttributes<E, Collections>
+                                                    ? CollectionPageAttributes<E, Collections>[Collection]
+                                                    : {},
+                                                Collection extends keyof CollectionIndexAttributes<E, Collections>
+                                                    ? CollectionIndexAttributes<E, Collections>[Collection]
+                                                    : {}
+                                                >
+                                            >
+                                        >>
+                                : never
+                            : never
+                        : never
+                }[Collections[Collection]];
+            }
+            : never
+    }[keyof E];
+}
+
+export type ElectroDBMethodTypes = "put" | "get" | "query" | "scan" | "update" | "delete" | "remove" | "patch" | "create" | "batchGet" | "batchWrite";
+
+export interface ElectroQueryEvent<P extends any = any> {
+    type: 'query';
+    method: ElectroDBMethodTypes;
+    config: any;
+    params: P;
+}
+
+export interface ElectroResultsEvent<R extends any = any> {
+    type: 'results';
+    method: ElectroDBMethodTypes;
+    config: any;
+    results: R;
+    success: boolean;
+}
+
+export type ElectroEvent =
+    ElectroQueryEvent
+    | ElectroResultsEvent;
+
+export type ElectroEventType = Pick<ElectroEvent, 'type'>;
+
+export type ElectroEventListener = (event: ElectroEvent) => void;
+
+// todo: coming soon, more events!
+// | {
+//     name: "error";
+//     type: "configuration_error" | "invalid_query" | "dynamodb_client";
+//     message: string;
+//     details: ElectroError;
+// } | {
+//     name: "error";
+//     type: "user_defined";
+//     message: string;
+//     details: ElectroValidationError;
+// } | {
+//     name: "warn";
+//     type: "deprecation_warning" | "optimization_suggestion";
+//     message: string;
+//     details: any;
+// } | {
+//     name: "info";
+//     type: "client_updated" | "table_overwritten";
+//     message: string;
+//     details: any;
+// };
+
+export type EntityItem<E extends Entity<any, any, any, any>> =
+    E extends Entity<infer A, infer F, infer C, infer S>
+        ? ResponseItem<A, F, C, S>
+        : never;
+
+export type CreateEntityItem<E extends Entity<any, any, any, any>> =
+    E extends Entity<infer A, infer F, infer C, infer S>
+        ? PutItem<A, F, C, S>
+        : never;
+
+export type UpdateEntityItem<E extends Entity<any, any, any, any>> =
+    E extends Entity<infer A, infer F, infer C, infer S>
+        ? Partial<ResponseItem<A,F,C,S>>
+        : never;
+
+export type UpdateAddEntityItem<E extends Entity<any, any, any, any>> =
+    E extends Entity<infer A, infer F, infer C, infer S>
+        ? AddItem<A, F, C, S>
+        : never;
+
+export type UpdateSubtractEntityItem<E extends Entity<any, any, any, any>> =
+    E extends Entity<infer A, infer F, infer C, infer S>
+        ? SubtractItem<A, F, C, S>
+        : never;
+
+export type UpdateAppendEntityItem<E extends Entity<any, any, any, any>> =
+    E extends Entity<infer A, infer F, infer C, infer S>
+        ? AppendItem<A, F, C, S>
+        : never;
+
+export type UpdateRemoveEntityItem<E extends Entity<any, any, any, any>> =
+    E extends Entity<infer A, infer F, infer C, infer S>
+        ? RemoveItem<A, F, C, S>
+        : never;
+
+export type UpdateDeleteEntityItem<E extends Entity<any, any, any, any>> =
+    E extends Entity<infer A, infer F, infer C, infer S>
+        ? DeleteItem<A, F, C, S>
+        : never;
+
+export type EntityRecord<E extends Entity<any, any, any, any>> =
+    E extends Entity<infer A, infer F, infer C, infer S>
+        ? Item<A,F,C,S,S["attributes"]>
+        : never;
+
+export type CollectionItem<SERVICE extends Service<any>, COLLECTION extends keyof SERVICE["collections"]> =
+    SERVICE extends Service<infer E>
+        ? Pick<{
+            [EntityName in keyof E]: E[EntityName] extends Entity<infer A, infer F, infer C, infer S>
+            ? COLLECTION extends keyof CollectionAssociations<E>
+                ? EntityName extends CollectionAssociations<E>[COLLECTION]
+                    ? ResponseItem<A,F,C,S>[]
+                    : never
+                : never
+            : never
+        }, COLLECTION extends keyof CollectionAssociations<E>
+        ? CollectionAssociations<E>[COLLECTION]
+        : never>
+        : never
+
+
+export interface RecordsActionOptions<A extends string,
+    F extends string, C extends string, S extends Schema<A,F,C>, Items, IndexCompositeAttributes> {
+    go: GoRecord<Items>;
+    params: ParamRecord;
+    page: PageRecord<Items,IndexCompositeAttributes>;
+    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,RecordsActionOptions<A,F,C,S,Items,IndexCompositeAttributes>>;
+}
+
+export interface SingleRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
+    go: GoRecord<ResponseType, QueryOptions>;
+    params: ParamRecord<QueryOptions>;
+    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,SingleRecordOperationOptions<A,F,C,S,ResponseType>>;
+}
+
+export interface PutRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
+    go: GoRecord<ResponseType, PutQueryOptions>;
+    params: ParamRecord<PutQueryOptions>;
+    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,PutRecordOperationOptions<A,F,C,S,ResponseType>>;
+}
+
+export interface UpdateRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
+    go: GoRecord<ResponseType, UpdateQueryOptions>;
+    params: ParamRecord<UpdateQueryParams>;
+    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,PutRecordOperationOptions<A,F,C,S,ResponseType>>;
+}
+
+export interface DeleteRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
+    go: GoRecord<ResponseType, DeleteQueryOptions>;
+    params: ParamRecord<DeleteQueryOptions>;
+    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,DeleteRecordOperationOptions<A,F,C,S,ResponseType>>;
+}
+
+export interface BulkRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType, AlternateResponseType> {
+    go: BatchGoRecord<ResponseType, AlternateResponseType>;
+    params: ParamRecord<BulkOptions>;
+}
+
+export interface SetRecordActionOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, SetAttr,IndexCompositeAttributes,TableItem> {
+    go: GoRecord<Partial<TableItem>, UpdateQueryOptions>;
+    params: ParamRecord<UpdateQueryParams>;
+    set: SetRecord<A,F,C,S, SetItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    remove: SetRecord<A,F,C,S, Array<keyof SetItem<A,F,C,S>>,IndexCompositeAttributes,TableItem>;
+    add: SetRecord<A,F,C,S, AddItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    subtract: SetRecord<A,F,C,S, SubtractItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    append: SetRecord<A,F,C,S, AppendItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    delete: SetRecord<A,F,C,S, DeleteItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    data: DataUpdateMethodRecord<A,F,C,S, Item<A,F,C,S,S["attributes"]>,IndexCompositeAttributes,TableItem>;
+    where: WhereClause<A,F,C,S, Item<A,F,C,S,S["attributes"]>,SetRecordActionOptions<A,F,C,S,SetAttr,IndexCompositeAttributes,TableItem>>;
+}
+
+export type SetRecord<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, SetAttr, IndexCompositeAttributes, TableItem> = (properties: SetAttr) => SetRecordActionOptions<A,F,C,S, SetAttr, IndexCompositeAttributes, TableItem>;
+export type RemoveRecord<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, RemoveAttr, IndexCompositeAttributes, TableItem> = (properties: RemoveAttr) => SetRecordActionOptions<A,F,C,S, RemoveAttr, IndexCompositeAttributes, TableItem>;
+
+export type DataUpdateMethodRecord<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, SetAttr, IndexCompositeAttributes, TableItem> =
+    DataUpdateMethod<A,F,C,S, UpdateData<A,F,C,S>, SetRecordActionOptions<A,F,C,S, SetAttr, IndexCompositeAttributes, TableItem>>
+
+interface QueryOperations<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, CompositeAttributes, TableItem, IndexCompositeAttributes> {
+    between: (skCompositeAttributesStart: CompositeAttributes, skCompositeAttributesEnd: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
+    gt: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
+    gte: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
+    lt: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
+    lte: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
+    begins: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
+    go: GoRecord<Array<TableItem>>;
+    params: ParamRecord;
+    page: PageRecord<Array<TableItem>,IndexCompositeAttributes>;
+    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,RecordsActionOptions<A,F,C,S,Array<TableItem>,IndexCompositeAttributes>>
+}
+
+export type Queries<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = {
+    [I in keyof S["indexes"]]: <CompositeAttributes extends IndexCompositeAttributes<A,F,C,S,I>>(composite: CompositeAttributes) =>
+        IndexSKAttributes<A,F,C,S,I> extends infer SK
+            // If there is no SK, dont show query operations (when an empty array is provided)
+            ? [keyof SK] extends [never]
+            ? RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S> & Required<CompositeAttributes>>
+            // If there is no SK, dont show query operations (When no PK is specified)
+            : S["indexes"][I] extends IndexWithSortKey
+                ? QueryOperations<
+                    A,F,C,S,
+                    // Omit the composite attributes already provided
+                    Omit<Partial<IndexSKAttributes<A,F,C,S,I>>, keyof CompositeAttributes>,
+                    ResponseItem<A,F,C,S>,
+                    AllTableIndexCompositeAttributes<A,F,C,S> & Required<CompositeAttributes> & SK
+                    >
+                : RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S> & Required<CompositeAttributes> & SK>
+            : never
+}
+
+export type ParseSingleInput = {
+    Item?: {[key: string]: any}
+} | {
+    Attributes?: {[key: string]: any}
+} | null;
+
+export type ParseMultiInput = {
+    Items?: {[key: string]: any}[]
+}
+
+export type ReturnValues = "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
+
+export interface QueryOptions {
+    raw?: boolean;
+    table?: string;
+    limit?: number;
+    params?: object;
+    includeKeys?: boolean;
+    originalErr?: boolean;
+    ignoreOwnership?: boolean;
+    pages?: number;
+    listeners?: Array<ElectroEventListener>;
+    logger?: ElectroEventListener;
+}
+
+// subset of QueryOptions
+export interface ParseOptions {
+    ignoreOwnership?: boolean;
+}
+
+export interface UpdateQueryOptions extends QueryOptions {
+    response?: "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
+}
+
+export interface UpdateQueryParams {
+    response?: "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
+    table?: string;
+    params?: object;
+    originalErr?: boolean;
+}
+
+export interface DeleteQueryOptions extends QueryOptions {
+    response?: "default" | "none" | 'all_old';
+}
+
+export interface PutQueryOptions extends QueryOptions {
+    response?: "default" | "none" | 'all_old';
+}
+
+export interface ParamOptions {
+    params?: object;
+    table?: string;
+    limit?: number;
+    response?: "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
+}
+
+export interface PaginationOptions extends QueryOptions {
+    pager?: "raw" | "item" | "named";
+    limit?: number;
+}
+
+export interface BulkOptions extends QueryOptions {
+    unprocessed?: "raw" | "item";
+    concurrency?: number;
+    preserveBatchOrder?: boolean;
+}
+
+export type OptionalDefaultEntityIdentifiers = {
+    __edb_e__?: string;
+    __edb_v__?: string;
+}
+
+export type GoRecord<ResponseType, Options = QueryOptions> = <T = ResponseType>(options?: Options) => Promise<T>;
+
+export type BatchGoRecord<ResponseType, AlternateResponseType> = <O extends BulkOptions>(options?: O) =>
+    O extends infer Options
+        ? 'preserveBatchOrder' extends keyof Options
+        ? Options['preserveBatchOrder'] extends true
+            ? Promise<AlternateResponseType>
+            : Promise<ResponseType>
+        : Promise<ResponseType>
+        : never
+
+export type PageRecord<ResponseType, CompositeAttributes> = (page?: (CompositeAttributes & OptionalDefaultEntityIdentifiers) | null, options?: PaginationOptions) => Promise<[
+        (CompositeAttributes & OptionalDefaultEntityIdentifiers) | null,
+    ResponseType
+]>;
+
+export type ParamRecord<Options = ParamOptions> = <P>(options?: Options) => P;
 
 export interface ElectroError extends Error {
     readonly name: 'ElectroError';
@@ -20,7 +541,7 @@ export interface ElectroError extends Error {
     }
 }
 
-interface ElectroValidationErrorFieldReference<T extends Error = Error> {
+export interface ElectroValidationErrorFieldReference<T extends Error = Error> {
     /**
      * The json path to the attribute that had a validation error
      */
@@ -46,23 +567,27 @@ export interface ElectroValidationError<T extends Error = Error> extends Electro
     readonly fields: ReadonlyArray<ElectroValidationErrorFieldReference<T>>;
 }
 
-interface ReadOnlyAttribute {
+export interface ReadOnlyAttribute {
     readonly readOnly: true;
 }
 
-interface RequiredAttribute {
-    readonly required: true;
+export interface RequiredAttribute {
+    required: true;
 }
 
-interface HiddenAttribute {
+export interface HiddenAttribute {
     readonly hidden: true;
 }
 
-interface DefaultedAttribute {
+export interface DefaultedAttribute {
     readonly default: any;
 }
 
-type NestedBooleanAttribute = {
+export interface SecondaryIndex {
+    readonly index: string;
+}
+
+export interface NestedBooleanAttribute {
     readonly type: "boolean";
     readonly required?: boolean;
     readonly hidden?: boolean;
@@ -74,7 +599,7 @@ type NestedBooleanAttribute = {
     readonly field?: string;
 }
 
-type BooleanAttribute = {
+export interface BooleanAttribute {
     readonly type: "boolean";
     readonly required?: boolean;
     readonly hidden?: boolean;
@@ -88,7 +613,7 @@ type BooleanAttribute = {
     readonly watch?: ReadonlyArray<string> | "*";
 }
 
-type NestedNumberAttribute = {
+export interface NestedNumberAttribute {
     readonly type: "number";
     readonly required?: boolean;
     readonly hidden?: boolean;
@@ -100,7 +625,7 @@ type NestedNumberAttribute = {
     readonly field?: string;
 }
 
-type NumberAttribute = {
+export interface NumberAttribute {
     readonly type: "number";
     readonly required?: boolean;
     readonly hidden?: boolean;
@@ -114,7 +639,7 @@ type NumberAttribute = {
     readonly watch?: ReadonlyArray<string> | "*";
 }
 
-type NestedStringAttribute = {
+export interface NestedStringAttribute {
     readonly type: "string";
     readonly required?: boolean;
     readonly hidden?: boolean;
@@ -126,7 +651,7 @@ type NestedStringAttribute = {
     readonly field?: string;
 }
 
-type StringAttribute = {
+export interface StringAttribute {
     readonly type: "string";
     readonly required?: boolean;
     readonly hidden?: boolean;
@@ -140,7 +665,7 @@ type StringAttribute = {
     readonly watch?: ReadonlyArray<string> | "*";
 }
 
-type NestedEnumAttribute = {
+export interface NestedEnumAttribute {
     readonly type: ReadonlyArray<string>;
     readonly required?: boolean;
     readonly hidden?: boolean;
@@ -154,7 +679,7 @@ type NestedEnumAttribute = {
 }
 
 
-type EnumAttribute = {
+export interface EnumAttribute {
     readonly type: ReadonlyArray<string>;
     readonly required?: boolean;
     readonly hidden?: boolean;
@@ -168,7 +693,7 @@ type EnumAttribute = {
     readonly watch?: ReadonlyArray<string> | "*";
 }
 
-type NestedAnyAttribute = {
+export interface NestedAnyAttribute {
     readonly type: "any";
     readonly required?: boolean;
     readonly hidden?: boolean;
@@ -180,7 +705,7 @@ type NestedAnyAttribute = {
     readonly field?: string;
 }
 
-type AnyAttribute = {
+export interface AnyAttribute {
     readonly type: "any";
     readonly required?: boolean;
     readonly hidden?: boolean;
@@ -194,7 +719,7 @@ type AnyAttribute = {
     readonly watch?: ReadonlyArray<string> | "*";
 }
 
-type NestedMapAttribute = {
+export interface NestedMapAttribute {
     readonly type: "map";
     readonly properties: {
         readonly [name: string]: NestedAttributes;
@@ -209,7 +734,7 @@ type NestedMapAttribute = {
     readonly field?: string;
 }
 
-type MapAttribute = {
+export interface MapAttribute {
     readonly type: "map";
     readonly properties: {
         readonly [name: string]: NestedAttributes;
@@ -225,7 +750,7 @@ type MapAttribute = {
     readonly watch?: ReadonlyArray<string> | "*";
 }
 
-type NestedStringListAttribute = {
+export interface NestedStringListAttribute {
     readonly type: "list";
     readonly items: {
         readonly type: "string";
@@ -247,7 +772,7 @@ type NestedStringListAttribute = {
     readonly validate?: ((val: Array<string>) => boolean) | ((val: Array<string>) => void) | ((val: Array<string>) => string | void);
 }
 
-type StringListAttribute = {
+export interface StringListAttribute {
     readonly type: "list";
     readonly items: {
         readonly type: "string";
@@ -270,7 +795,7 @@ type StringListAttribute = {
     readonly watch?: ReadonlyArray<string> | "*";
 }
 
-type NestedNumberListAttribute = {
+export interface NestedNumberListAttribute {
     readonly type: "list";
     readonly items: NestedNumberAttribute;
     readonly required?: boolean;
@@ -283,7 +808,7 @@ type NestedNumberListAttribute = {
     readonly field?: string;
 }
 
-type NumberListAttribute = {
+export interface NumberListAttribute {
     readonly type: "list";
     readonly items: NestedNumberAttribute;
     readonly required?: boolean;
@@ -297,7 +822,7 @@ type NumberListAttribute = {
     readonly watch?: ReadonlyArray<string> | "*";
 }
 
-type NestedMapListAttribute = {
+export interface NestedMapListAttribute {
     readonly type: "list";
     readonly items: NestedMapAttribute;
     readonly required?: boolean;
@@ -310,7 +835,7 @@ type NestedMapListAttribute = {
     readonly field?: string;
 }
 
-type MapListAttribute = {
+export interface MapListAttribute {
     readonly type: "list";
     readonly items: NestedMapAttribute;
     readonly required?: boolean;
@@ -324,7 +849,7 @@ type MapListAttribute = {
     readonly watch?: ReadonlyArray<string> | "*";
 }
 
-type NestedStringSetAttribute = {
+export interface NestedStringSetAttribute {
     readonly type: "set";
     readonly items: "string";
     readonly required?: boolean;
@@ -337,7 +862,7 @@ type NestedStringSetAttribute = {
     readonly field?: string;
 }
 
-type StringSetAttribute = {
+export interface StringSetAttribute {
     readonly type: "set";
     readonly items: "string";
     readonly required?: boolean;
@@ -351,7 +876,7 @@ type StringSetAttribute = {
     readonly watch?: ReadonlyArray<string> | "*";
 }
 
-type NestedNumberSetAttribute = {
+export interface NestedNumberSetAttribute {
     readonly type: "set";
     readonly items: "number";
     readonly required?: boolean;
@@ -364,7 +889,7 @@ type NestedNumberSetAttribute = {
     readonly field?: string;
 }
 
-type NumberSetAttribute = {
+export interface NumberSetAttribute {
     readonly type: "set";
     readonly items: "number";
     readonly required?: boolean;
@@ -378,7 +903,7 @@ type NumberSetAttribute = {
     readonly watch?: ReadonlyArray<string> | "*";
 }
 
-type Attribute =
+export type Attribute =
     BooleanAttribute
     | NumberAttribute
     | StringAttribute
@@ -391,7 +916,7 @@ type Attribute =
     | NumberListAttribute
     | MapListAttribute;
 
-type NestedAttributes =
+export type NestedAttributes =
     NestedBooleanAttribute
     | NestedNumberAttribute
     | NestedStringAttribute
@@ -402,27 +927,9 @@ type NestedAttributes =
     | NestedMapListAttribute
     | NestedStringSetAttribute
     | NestedNumberSetAttribute
-    | NestedEnumAttribute
-
-type Attributes<A extends string> = {
-    readonly [a in A]: Attribute
-}
+    | NestedEnumAttribute;
 
-type SecondaryIndex = {
-    readonly index: string;
-    readonly pk: {
-        readonly field: string;
-        readonly composite: ReadonlyArray<string>;
-        readonly template?: string;
-    }
-    readonly sk?: {
-        readonly field: string;
-        readonly composite: ReadonlyArray<string>;
-        readonly template?: string;
-    }
-}
-
-type IndexWithSortKey = {
+export interface IndexWithSortKey {
     readonly sk: {
         readonly field: string;
         readonly composite: ReadonlyArray<string>;
@@ -430,9 +937,9 @@ type IndexWithSortKey = {
     }
 }
 
-type AccessPatternCollection<C extends string> = C | ReadonlyArray<C>;
+export type AccessPatternCollection<C extends string> = C | ReadonlyArray<C>;
 
-type Schema<A extends string, F extends A, C extends string> = {
+export interface Schema<A extends string, F extends string, C extends string> {
     readonly model: {
         readonly entity: string;
         readonly service: string;
@@ -444,7 +951,7 @@ type Schema<A extends string, F extends A, C extends string> = {
     readonly indexes: {
         [accessPattern: string]: {
             readonly index?: string;
-            readonly collection?: C | ReadonlyArray<C>;
+            readonly collection?: AccessPatternCollection<C>;
             readonly pk: {
                 readonly casing?: "upper" | "lower" | "none" | "default";
                 readonly field: string;
@@ -459,16 +966,18 @@ type Schema<A extends string, F extends A, C extends string> = {
             }
         }
     }
-};
+}
+
+export type Attributes<A extends string> = Record<A, Attribute>
 
-type IndexCollections<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = {
+export type IndexCollections<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = {
     [i in keyof S["indexes"]]: S["indexes"][i]["collection"] extends
         AccessPatternCollection<infer Name>
-            ? Name
-            : never
+        ? Name
+        : never
 }[keyof S["indexes"]];
 
-type EntityCollections<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = {
+export type EntityCollections<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = {
     [N in IndexCollections<A,F,C,S>]: {
         [i in keyof S["indexes"]]: S["indexes"][i]["collection"] extends AccessPatternCollection<infer Name>
             ? Name extends N
@@ -478,7 +987,20 @@ type EntityCollections<A extends string, F extends A, C extends string, S extend
     }[keyof S["indexes"]];
 }
 
-type ItemAttribute<A extends Attribute> =
+declare const SkipSymbol: unique symbol;
+type SkipValue = typeof SkipSymbol;
+
+type PartialDefinedKeys<T> = {
+    [P in keyof T as
+        [undefined] extends [T[P]]
+            ? never
+            : SkipValue extends T[P]
+            ? never
+            : P
+    ]?: T[P] | undefined;
+}
+
+export type ItemAttribute<A extends Attribute> =
     A["type"] extends infer R
         ? R extends "string" ? string
         : R extends "number" ? number
@@ -490,8 +1012,8 @@ type ItemAttribute<A extends Attribute> =
                                 [P in keyof A["properties"]]:
                                 A["properties"][P] extends infer M
                                     ? M extends Attribute
-                                        ? ItemAttribute<M>
-                                        : never
+                                    ? ItemAttribute<M>
+                                    : never
                                     : never
                             }
                             : never
@@ -515,9 +1037,20 @@ type ItemAttribute<A extends Attribute> =
                                     : never
         : never
 
-type ReturnedAttribute<A extends Attribute> =
-    A extends HiddenAttribute ? never
-        : A["type"] extends infer R
+type FormattedPutMapAttributes<A extends MapAttribute> = {
+    [P in keyof A["properties"]]: A["properties"][P] extends infer M
+        ? M extends HiddenAttribute
+            ? false
+            : M extends DefaultedAttribute
+                ? false
+                : M extends RequiredAttribute
+                    ? true
+                    : false
+        : false
+}
+
+export type ReturnedAttribute<A extends Attribute> =
+    A["type"] extends infer R
         ? R extends "string" ? string
         : R extends "number" ? number
             : R extends "boolean" ? boolean
@@ -525,15 +1058,48 @@ type ReturnedAttribute<A extends Attribute> =
                     : R extends "map"
                         ? "properties" extends keyof A
                             ?
-                            TrimmedAttributes<{
-                                [P in keyof A["properties"]]: A["properties"][P] extends infer M
-                                    ? M extends Attribute
-                                        ? M extends RequiredAttribute | DefaultedAttribute
-                                            ? ReturnedAttribute<M>
-                                            : ReturnedAttribute<M> | undefined
-                                        : never
+                            {
+                                [
+                                P in keyof A["properties"] as A["properties"][P] extends RequiredAttribute
+                                    ? P
+                                    : never
+                                ]: A["properties"][P] extends infer M
+                                ? M extends Attribute
+                                    ? ReturnedAttribute<M>
+                                    : never
+                                : never
+                            } & {
+                            [
+                            P in keyof A["properties"] as A["properties"][P] extends HiddenAttribute | RequiredAttribute
+                                ? never
+                                : P
+                            ]?: A["properties"][P] extends infer M
+                                ? M extends Attribute
+                                    ? ReturnedAttribute<M> | undefined
                                     : never
-                            }>
+                                : never
+                        }
+                            // SkipKeys<{
+                            //     [P in keyof A["properties"]]: A["properties"][P] extends infer M
+                            //         ? M extends Attribute
+                            //           ? M extends HiddenAttribute
+                            //             ? SkipValue
+                            //             : M extends RequiredAttribute
+                            //                 ? ReturnedAttribute<M>
+                            //                 : SkipValue
+                            //             : never
+                            //           : never
+                            // }> & SkipKeys<{
+                            //   [P in keyof A["properties"]]?: A["properties"][P] extends infer M
+                            //         ? M extends Attribute
+                            //           ? M extends HiddenAttribute
+                            //             ? SkipValue
+                            //             : M extends RequiredAttribute
+                            //                 ? SkipValue
+                            //                 : ReturnedAttribute<M> | undefined
+                            //             : never
+                            //           : never
+                            // }>
                             : never
                         : R extends "list"
                             ? "items" extends keyof A
@@ -555,32 +1121,57 @@ type ReturnedAttribute<A extends Attribute> =
                                     : never
         : never
 
-type UndefinedKeys<T> = {
-    [P in keyof T]: undefined extends T[P] ? P: never
-}[keyof T]
-
-type TrimmedAttributes<A extends Attributes<any>> =
-    Partial<Pick<A, UndefinedKeys<A>>> & Omit<A, UndefinedKeys<A>>
-
-type CreatedAttribute<A extends Attribute> =
+export type CreatedAttribute<A extends Attribute> =
     A["type"] extends infer R
-    ? R extends "string" ? string
+        ? R extends "string" ? string
         : R extends "number" ? number
             : R extends "boolean" ? boolean
                 : R extends ReadonlyArray<infer E> ? E
                     : R extends "map"
                         ? "properties" extends keyof A
-                            ? TrimmedAttributes<{
-                                [P in keyof A["properties"]]: A["properties"][P] extends infer M
-                                    ? M extends Attribute
-                                        ? M extends DefaultedAttribute
-                                            ? CreatedAttribute<M> | undefined
-                                            : M extends RequiredAttribute
-                                                ? CreatedAttribute<M>
-                                                : CreatedAttribute<M> | undefined
-                                        : never
+                            ? {
+                            [
+                            P in keyof A["properties"] as A["properties"][P] extends RequiredAttribute
+                                ? A["properties"][P] extends DefaultedAttribute
+                                    ? never
+                                    : P
+                                : never
+                            ]: A["properties"][P] extends infer M
+                                ? M extends Attribute
+                                    ? CreatedAttribute<M>
+                                    : never
+                                : never
+                        } & {
+                            [P in keyof A["properties"] as A["properties"][P] extends HiddenAttribute
+                                ? never
+                                : P
+                            ]?: A["properties"][P] extends infer M
+                                ? M extends Attribute
+                                    ? CreatedAttribute<M> | undefined
+                                    : never
                                 : never
-                            }>
+                        }
+                            // ? SkipKeys<{
+                            //     [P in keyof A["properties"]]: A["properties"][P] extends infer M
+                            //         ? M extends Attribute
+                            //             ? M extends HiddenAttribute
+                            //               ? SkipValue
+                            //               : M extends DefaultedAttribute
+                            //                   ? SkipValue
+                            //                   : M extends RequiredAttribute
+                            //                       ? CreatedAttribute<M>
+                            //                       : SkipValue
+                            //             : never
+                            //     : never
+                            // }> & SkipKeys<{
+                            //   [P in keyof A["properties"]]?: A["properties"][P] extends infer M
+                            //     ? M extends Attribute
+                            //       ? M extends HiddenAttribute
+                            //         ? SkipValue
+                            //         : CreatedAttribute<M> | undefined
+                            //       : never
+                            //     : never
+                            // }>
                             : never
                         : R extends "list"
                             ? "items" extends keyof A
@@ -600,34 +1191,38 @@ type CreatedAttribute<A extends Attribute> =
                                     : never
                                 : R extends "any" ? any
                                     : never
-    : never
+        : never
 
-type ReturnedItem<A extends string, F extends A, C extends string, S extends Schema<A,F,C>,Attr extends S["attributes"]> = {
+export type ReturnedItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>,Attr extends S["attributes"]> = {
     [a in keyof Attr]: ReturnedAttribute<Attr[a]>
 }
 
-type CreatedItem<A extends string, F extends A, C extends string, S extends Schema<A,F,C>,Attr extends S["attributes"]> = {
+export type CreatedItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>,Attr extends S["attributes"]> = {
     [a in keyof Attr]: CreatedAttribute<Attr[a]>
 }
 
-type EditableItemAttribute<A extends Attribute> =
+export type EditableItemAttribute<A extends Attribute> =
     A extends ReadOnlyAttribute
         ? never
         : A["type"] extends infer R
-            ? R extends "string" ? string
+        ? R extends "string" ? string
             : R extends "number" ? number
                 : R extends "boolean" ? boolean
                     : R extends ReadonlyArray<infer E> ? E
                         : R extends "map"
                             ? "properties" extends keyof A
-                                ? TrimmedAttributes<{
-                                    [P in keyof A["properties"]]:
+                                ? {
+                                    [
+                                    P in keyof A["properties"] as A["properties"][P] extends ReadOnlyAttribute
+                                        ? never
+                                        : P
+                                    ]:
                                     A["properties"][P] extends infer M
                                         ? M extends Attribute
-                                            ? EditableItemAttribute<M>
-                                            : never
+                                        ? EditableItemAttribute<M>
+                                        : never
                                         : never
-                                }>
+                                }
                                 : never
                             : R extends "list"
                                 ? "items" extends keyof A
@@ -647,26 +1242,45 @@ type EditableItemAttribute<A extends Attribute> =
                                         : never
                                     : R extends "any" ? any
                                         : never
-            : never    
-            
-type UpdatableItemAttribute<A extends Attribute> =
+        : never
+
+export type UpdatableItemAttribute<A extends Attribute> =
     A extends ReadOnlyAttribute
         ? never
         : A["type"] extends infer R
-            ? R extends "string" ? string
+        ? R extends "string" ? string
             : R extends "number" ? number
                 : R extends "boolean" ? boolean
                     : R extends ReadonlyArray<infer E> ? E
                         : R extends "map"
                             ? "properties" extends keyof A
                                 ? {
-                                    [P in keyof A["properties"]]?:
-                                    A["properties"][P] extends infer M
-                                        ? M extends Attribute
-                                            ? UpdatableItemAttribute<M>
-                                            : never
+                                [
+                                P in keyof A["properties"] as A["properties"][P] extends ReadOnlyAttribute
+                                    ? never
+                                    : A["properties"][P] extends RequiredAttribute
+                                        ? P
                                         : never
-                                }
+                                ]:
+                                A["properties"][P] extends infer M
+                                    ? M extends Attribute
+                                    ? UpdatableItemAttribute<M>
+                                    : never
+                                    : never
+                            } & {
+                                [
+                                P in keyof A["properties"] as A["properties"][P] extends ReadOnlyAttribute
+                                    ? never
+                                    : A["properties"][P] extends RequiredAttribute
+                                        ? never
+                                        : P
+                                ]?:
+                                A["properties"][P] extends infer M
+                                    ? M extends Attribute
+                                    ? UpdatableItemAttribute<M>
+                                    : never
+                                    : never
+                            }
                                 : never
                             : R extends "list"
                                 ? "items" extends keyof A
@@ -686,9 +1300,9 @@ type UpdatableItemAttribute<A extends Attribute> =
                                         : never
                                     : R extends "any" ? any
                                         : never
-            : never
+        : never
 
-type RemovableItemAttribute<A extends Attribute> =
+export type RemovableItemAttribute<A extends Attribute> =
     A extends ReadOnlyAttribute | RequiredAttribute
         ? never
         : A["type"] extends infer R
@@ -699,11 +1313,15 @@ type RemovableItemAttribute<A extends Attribute> =
                         : R extends "map"
                             ? "properties" extends keyof A
                                 ? {
-                                    [P in keyof A["properties"]]?:
+                                    [
+                                    P in keyof A["properties"] as A["properties"][P] extends ReadOnlyAttribute | RequiredAttribute
+                                        ? never
+                                        : P
+                                    ]?:
                                     A["properties"][P] extends infer M
                                         ? M extends Attribute
-                                            ? UpdatableItemAttribute<M>
-                                            : never
+                                        ? UpdatableItemAttribute<M>
+                                        : never
                                         : never
                                 }
                                 : never
@@ -727,167 +1345,193 @@ type RemovableItemAttribute<A extends Attribute> =
                                         : never
         : never
 
-type Item<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, Attr extends Attributes<A>> = {
+export type Item<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, Attr extends Attributes<A>> = {
     [a in keyof Attr]: ItemAttribute<Attr[a]>
 }
 
-type ItemTypeDescription<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = {
+export type ItemTypeDescription<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = {
     [a in keyof S["attributes"]]: S["attributes"][a]["type"] extends infer R
         ? R
         : never
 }
 
-type RequiredAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = ExtractKeysOfValueType<{
-    [a in keyof S["attributes"]]: S["attributes"][a]["required"] extends infer R
-        ? R extends true ? true
-            : false
-        : never;
+export type RequiredAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = ExtractKeysOfValueType<{
+    [a in keyof S["attributes"]]: S["attributes"][a] extends RequiredAttribute
+        ? true
+        : false
 }, true>
 
-type HiddenAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = ExtractKeysOfValueType<{
-    [a in keyof S["attributes"]]: S["attributes"][a]["hidden"] extends infer R
-        ? R extends true
-            ? true
-            : false
-        : never;
+export type HiddenAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = ExtractKeysOfValueType<{
+    [a in keyof S["attributes"]]: S["attributes"][a] extends HiddenAttribute
+        ? true
+        : false
 }, true>
 
-type ReadOnlyAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = ExtractKeysOfValueType<{
-    [a in keyof S["attributes"]]: S["attributes"][a]["readOnly"] extends infer R
-        ? R extends true
-            ? true
-            : false
-        : never;
+export type ReadOnlyAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = ExtractKeysOfValueType<{
+    [a in keyof S["attributes"]]: S["attributes"][a] extends ReadOnlyAttribute
+        ? true
+        : false
 }, true>
 
 type ExtractKeysOfValueType<T, K> = {
     [I in keyof T]: T[I] extends K ? I : never
 }[keyof T];
 
-type TableIndexes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = {
-    [i in keyof S["indexes"]]: S["indexes"][i] extends infer I
-        ? I extends SecondaryIndex
-            ? "secondary"
-            : "table"
-        : never;
+export type TableIndexes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = {
+    [i in keyof S["indexes"]]: S["indexes"][i] extends SecondaryIndex
+        ? "secondary"
+        : "table"
 };
 
-type TableIndexName<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = ExtractKeysOfValueType<TableIndexes<A,F,C,S>, "table">;
+export type TableIndexName<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = ExtractKeysOfValueType<TableIndexes<A,F,C,S>, "table">;
 
-type PKCompositeAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = {
-    [i in keyof S["indexes"]]: S["indexes"][i]["pk"]["composite"][number];
+export type PKCompositeAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = {
+    [i in keyof S["indexes"]]: S["indexes"][i]["pk"]["composite"] extends ReadonlyArray<infer Composite>
+        ? Composite
+        : never
 }
 
-type SKCompositeAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = {
+export type SKCompositeAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = {
     [i in keyof S["indexes"]]: S["indexes"][i] extends IndexWithSortKey
-        ? S["indexes"][i]["sk"]["composite"][number]
+        ? S["indexes"][i]["sk"]["composite"] extends ReadonlyArray<infer Composite>
+            ? Composite
+            : never
         : never;
 }
 
-type TableIndexPKCompositeAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = Pick<PKCompositeAttributes<A,F,C,S>, TableIndexName<A,F,C,S>>;
+export type TableIndexPKCompositeAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = Pick<PKCompositeAttributes<A,F,C,S>, TableIndexName<A,F,C,S>>;
 
-type TableIndexSKCompositeAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = Pick<SKCompositeAttributes<A,F,C,S>, TableIndexName<A,F,C,S>>;
+export type TableIndexSKCompositeAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = Pick<SKCompositeAttributes<A,F,C,S>, TableIndexName<A,F,C,S>>;
 
-type IndexPKCompositeAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends keyof S["indexes"]> = Pick<PKCompositeAttributes<A,F,C,S>,I>;
+export type IndexPKCompositeAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends keyof S["indexes"]> = Pick<PKCompositeAttributes<A,F,C,S>,I>;
 
-type IndexSKCompositeAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends keyof S["indexes"]> = Pick<SKCompositeAttributes<A,F,C,S>,I>;
+export type IndexSKCompositeAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends keyof S["indexes"]> = Pick<SKCompositeAttributes<A,F,C,S>,I>;
 
-type TableIndexPKAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = Pick<Item<A,F,C,S,S["attributes"]>, TableIndexPKCompositeAttributes<A,F,C,S>[TableIndexName<A,F,C,S>]>;
+export type TableIndexPKAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
+    TableIndexName<A,F,C,S> extends keyof TableIndexPKCompositeAttributes<A,F,C,S>
+        ? TableIndexPKCompositeAttributes<A,F,C,S>[TableIndexName<A,F,C,S>] extends keyof Item<A,F,C,S,S["attributes"]>
+        ? Pick<Item<A,F,C,S,S["attributes"]>, TableIndexPKCompositeAttributes<A,F,C,S>[TableIndexName<A,F,C,S>]>
+        : never
+        : never
 
-type TableIndexSKAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = TableIndexSKCompositeAttributes<A,F,C,S>[TableIndexName<A,F,C,S>] extends keyof S["attributes"]
+export type TableIndexSKAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = TableIndexSKCompositeAttributes<A,F,C,S>[TableIndexName<A,F,C,S>] extends keyof S["attributes"]
     ? Pick<Item<A,F,C,S,S["attributes"]>, TableIndexSKCompositeAttributes<A,F,C,S>[TableIndexName<A,F,C,S>]>
     : Item<A,F,C,S,S["attributes"]>;
 
-type IndexPKAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends keyof S["indexes"]> = Pick<Item<A,F,C,S,S["attributes"]>, IndexPKCompositeAttributes<A,F,C,S,I>[I]>;
+export type IndexPKAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends keyof S["indexes"]> =
+    I extends keyof IndexPKCompositeAttributes<A,F,C,S,I>
+        ? IndexPKCompositeAttributes<A,F,C,S,I>[I] extends keyof Item<A,F,C,S,S["attributes"]>
+        ? Pick<Item<A,F,C,S,S["attributes"]>, IndexPKCompositeAttributes<A,F,C,S,I>[I]>
+        : never
+        : never;
 
-type IndexSKAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends keyof S["indexes"]> = IndexSKCompositeAttributes<A,F,C,S,I>[I] extends keyof S["attributes"]
+export type IndexSKAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends keyof S["indexes"]> = IndexSKCompositeAttributes<A,F,C,S,I>[I] extends keyof S["attributes"]
     ? Pick<Item<A,F,C,S,S["attributes"]>, IndexSKCompositeAttributes<A,F,C,S,I>[I]>
     : Item<A,F,C,S,S["attributes"]>;
 
-type TableIndexCompositeAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = TableIndexPKAttributes<A,F,C,S> & Partial<TableIndexSKAttributes<A,F,C,S>>;
+export type TableIndexCompositeAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = TableIndexPKAttributes<A,F,C,S> & Partial<TableIndexSKAttributes<A,F,C,S>>;
 
-type AllTableIndexCompositeAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = TableIndexPKAttributes<A,F,C,S> & TableIndexSKAttributes<A,F,C,S>;
+export type AllTableIndexCompositeAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = TableIndexPKAttributes<A,F,C,S> & TableIndexSKAttributes<A,F,C,S>;
 
-type IndexCompositeAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends keyof S["indexes"]> = IndexPKAttributes<A,F,C,S,I> & Partial<IndexSKAttributes<A,F,C,S,I>>;
+export type IndexCompositeAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends keyof S["indexes"]> = IndexPKAttributes<A,F,C,S,I> & Partial<IndexSKAttributes<A,F,C,S,I>>;
 
-type TableItem<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> =
+export type TableItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
     AllTableIndexCompositeAttributes<A,F,C,S> &
     Pick<ReturnedItem<A,F,C,S,S["attributes"]>, RequiredAttributes<A,F,C,S>> &
     Partial<Omit<ReturnedItem<A,F,C,S,S["attributes"]>, RequiredAttributes<A,F,C,S>>>
 
-type ResponseItem<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> =
+export type ResponseItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
     Omit<TableItem<A,F,C,S>, HiddenAttributes<A,F,C,S>>
 
-type RequiredPutItems<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = {
+export type RequiredPutItems<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = {
     [Attribute in keyof S["attributes"]]:
     "default" extends keyof S["attributes"][Attribute]
         ? false
         : "required" extends keyof S["attributes"][Attribute]
-            ? true extends S["attributes"][Attribute]["required"]
-                ? true
-                    : Attribute extends keyof TableIndexCompositeAttributes<A,F,C,S>
-                        ? true
-                        : false
+        ? true extends S["attributes"][Attribute]["required"]
+            ? true
             : Attribute extends keyof TableIndexCompositeAttributes<A,F,C,S>
                 ? true
                 : false
+        : Attribute extends keyof TableIndexCompositeAttributes<A,F,C,S>
+            ? true
+            : false
 }
 
-type PutItem<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> =
+export type PutItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
     Pick<CreatedItem<A,F,C,S,S["attributes"]>, ExtractKeysOfValueType<RequiredPutItems<A,F,C,S>,true>>
     & Partial<CreatedItem<A,F,C,S,S["attributes"]>>
 
-type UpdateData<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> =
+export type UpdateData<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
     Omit<{
         [Attr in keyof S["attributes"]]: EditableItemAttribute<S["attributes"][Attr]>
     }, keyof AllTableIndexCompositeAttributes<A,F,C,S> | ReadOnlyAttributes<A,F,C,S>>
 
-type SetItem<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> =
-    // UpdatableItemAttribute
+export type SetItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
+// UpdatableItemAttribute
     Omit<{
         [Attr in keyof S["attributes"]]?: UpdatableItemAttribute<S["attributes"][Attr]>
     }, keyof AllTableIndexCompositeAttributes<A,F,C,S> | ReadOnlyAttributes<A,F,C,S>>
 
-// type RemoveItem<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> =
+// type RemoveItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
 //     Array<keyof SetItem<A,F,C,S>>
-type RemoveItem<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> =
+export type RemoveItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
     Array< keyof Omit<{
         [Attr in keyof S["attributes"]]?: RemovableItemAttribute<S["attributes"][Attr]>
     }, keyof AllTableIndexCompositeAttributes<A,F,C,S> | ReadOnlyAttributes<A,F,C,S> | RequiredAttributes<A,F,C,S>>>
 
-type AppendItem<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> =
-    Partial<{
-        [P in ExtractKeysOfValueType<ItemTypeDescription<A,F,C,S>, "list" | "any">]?: P extends keyof SetItem<A,F,C,S>
-            ? SetItem<A,F,C,S>[P]
+export type AppendItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
+    {
+        [
+        P in keyof ItemTypeDescription<A,F,C,S> as ItemTypeDescription<A,F,C,S>[P] extends 'list' | 'any'
+            ? P
             : never
-    }>
+        ]?: P extends keyof SetItem<A,F,C,S>
+        ? SetItem<A,F,C,S>[P] | undefined
+        : never
+    }
 
-type AddItem<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> =
-    Partial<{
-        [P in ExtractKeysOfValueType<ItemTypeDescription<A,F,C,S>, "number" | "any" | "set">]?: P extends keyof SetItem<A,F,C,S>
-            ? SetItem<A,F,C,S>[P]
+export type AddItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
+    {
+        [
+        P in keyof ItemTypeDescription<A,F,C,S> as ItemTypeDescription<A,F,C,S>[P] extends "number" | "any" | "set"
+            ? P
             : never
-    }>
+        ]?: P extends keyof SetItem<A,F,C,S>
+        ? SetItem<A,F,C,S>[P] | undefined
+        : never
+    }
 
-type SubtractItem<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> =
-    Partial<{
-        [P in ExtractKeysOfValueType<ItemTypeDescription<A,F,C,S>, "number" | "any">]?: P extends keyof SetItem<A,F,C,S>
-            ? SetItem<A,F,C,S>[P]
+export type SubtractItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
+    {
+        [
+        P in keyof ItemTypeDescription<A,F,C,S> as ItemTypeDescription<A,F,C,S>[P] extends "number" | "any"
+            ? P
             : never
-    }>
+        ]?: P extends keyof SetItem<A,F,C,S>
+        ? SetItem<A,F,C,S>[P] | undefined
+        : never
+    }
 
-type DeleteItem<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> =
-    Partial<{
-        [P in ExtractKeysOfValueType<ItemTypeDescription<A,F,C,S>, "any" | "set">]?: P extends keyof SetItem<A,F,C,S>
-            ? SetItem<A,F,C,S>[P]
+export type DeleteItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
+    {
+        [
+        P in keyof ItemTypeDescription<A,F,C,S> as ItemTypeDescription<A,F,C,S>[P] extends "any" | "set"
+            ? P
             : never
-    }>
+        ]?: P extends keyof SetItem<A,F,C,S>
+        ? SetItem<A,F,C,S>[P] | undefined
+        : never
+    }
+
+export declare const WhereSymbol: unique symbol;
+export declare const UpdateDataSymbol: unique symbol;
 
 export type WhereAttributeSymbol<T extends any> =
-    { [WhereSymbol]: void }
+        { [WhereSymbol]: void }
     & T extends string ? T
-        : T extends number ? T
-        : T extends boolean ? T
+    : T extends number ? T
+    : T extends boolean ? T
         : T extends {[key: string]: any}
             ? {[key in keyof T]: WhereAttributeSymbol<T[key]>}
             : T extends ReadonlyArray<infer A>
@@ -896,17 +1540,17 @@ export type WhereAttributeSymbol<T extends any> =
                     ? Array<WhereAttributeSymbol<I>>
                     : T
 
-type WhereAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends Item<A,F,C,S,S["attributes"]>> = {
+export type WhereAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends Item<A,F,C,S,S["attributes"]>> = {
     [Attr in keyof I]: WhereAttributeSymbol<I[Attr]>
 }
 
-export type DataUpdateAttributeSymbol<T extends any> = 
-    { [UpdateDataSymbol]: void } 
+export type DataUpdateAttributeSymbol<T extends any> =
+        { [UpdateDataSymbol]: void }
     & T extends string ? T
     : T extends number ? T
     : T extends boolean ? T
-    : T extends {[key: string]: any}
-        ? {[key in keyof T]: DataUpdateAttributeSymbol<T[key]>}
+        : T extends {[key: string]: any}
+            ? {[key in keyof T]: DataUpdateAttributeSymbol<T[key]>}
             : T extends ReadonlyArray<infer A>
                 ? ReadonlyArray<DataUpdateAttributeSymbol<A>>
                 : T extends Array<infer I>
@@ -915,25 +1559,25 @@ export type DataUpdateAttributeSymbol<T extends any> =
                         ? never
                         : T
 
-type DataUpdateAttributeValues<A extends DataUpdateAttributeSymbol<any>> =
+export type DataUpdateAttributeValues<A extends DataUpdateAttributeSymbol<any>> =
     A extends DataUpdateAttributeSymbol<infer T>
         ? T extends string ? T
         : T extends number ? T
-        : T extends boolean ? T
-        : T extends {[key: string]: any}
-        ? {[key in keyof T]?: DataUpdateAttributeValues<T[key]>}
-        : T extends ReadonlyArray<infer A> ? ReadonlyArray<DataUpdateAttributeValues<A>>
-        : T extends Array<infer I> ? Array<DataUpdateAttributeValues<I>>
-        : [T] extends [never]
-        ? never
-        : T
-    : never
+            : T extends boolean ? T
+                : T extends {[key: string]: any}
+                    ? {[key in keyof T]?: DataUpdateAttributeValues<T[key]>}
+                    : T extends ReadonlyArray<infer A> ? ReadonlyArray<DataUpdateAttributeValues<A>>
+                        : T extends Array<infer I> ? Array<DataUpdateAttributeValues<I>>
+                            : [T] extends [never]
+                                ? never
+                                : T
+        : never
 
-type DataUpdateAttributes<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends UpdateData<A,F,C,S>> = {
+export type DataUpdateAttributes<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends UpdateData<A,F,C,S>> = {
     [Attr in keyof I]: DataUpdateAttributeSymbol<I[Attr]>
 }
 
-type WhereOperations<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends Item<A,F,C,S,S["attributes"]>> = {
+export interface WhereOperations<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends Item<A,F,C,S,S["attributes"]>> {
     eq: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
     ne: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
     gt: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
@@ -948,293 +1592,56 @@ type WhereOperations<A extends string, F extends A, C extends string, S extends
     notContains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
     value: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: A extends WhereAttributeSymbol<infer V> ? V : never) => A extends WhereAttributeSymbol<infer V> ? V : never;
     name: <A extends WhereAttributeSymbol<any>>(attr: A) => string;
-};
+}
 
-type DataUpdateOperations<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends UpdateData<A,F,C,S>> = {
+export interface DataUpdateOperations<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends UpdateData<A,F,C,S>> {
     set: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: DataUpdateAttributeValues<A>) => any;
     remove: <T, A extends DataUpdateAttributeSymbol<T>>(attr: [T] extends [never] ? never : A) => any;
     append: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: DataUpdateAttributeValues<A> extends Array<any> ? DataUpdateAttributeValues<A> : never) => any;
-    add: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: A extends DataUpdateAttributeSymbol<infer V> ? V extends number | Array<any> ? V : [V] extends [any] ? V : never : never ) => any;
-    subtract: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: A extends DataUpdateAttributeSymbol<infer V> ? V extends number ? V : [V] extends [any] ? V : never : never ) => any;
-    delete: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: A extends DataUpdateAttributeSymbol<infer V> ? V extends Array<any> ? V : [V] extends [any] ? V : never : never ) => any;
-    del:    <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: A extends DataUpdateAttributeSymbol<infer V> ? V extends Array<any> ? V : never : never ) => any;
-    value: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: DataUpdateAttributeValues<A>) => Required<DataUpdateAttributeValues<A>>;
-    name: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A) => any;
-    ifNotExists: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: DataUpdateAttributeValues<A>) => any;
-};
-
-type WhereCallback<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends Item<A,F,C,S,S["attributes"]>> =
-    <W extends WhereAttributes<A,F,C,S,I>>(attributes: W, operations: WhereOperations<A,F,C,S,I>) => string;
-
-type DataUpdateCallback<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends UpdateData<A,F,C,S>> =
-    <W extends DataUpdateAttributes<A,F,C,S,I>>(attributes: W, operations: DataUpdateOperations<A,F,C,S,I>) => any;
-
-type ReturnValues = "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
-
-interface QueryOptions {
-    raw?: boolean;
-    table?: string;
-    limit?: number;
-    params?: object;
-    includeKeys?: boolean;
-    originalErr?: boolean;
-    ignoreOwnership?: boolean;
-    pages?: number;
-    listeners?: Array<EventListener>;
-    logger?: EventListener;
-}
-
-// subset of QueryOptions
-interface ParseOptions {
-    ignoreOwnership?: boolean;
-}
-
-interface UpdateQueryOptions extends QueryOptions {
-    response?: "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
-}
-
-interface UpdateQueryParams {
-    response?: "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
-    table?: string;
-    params?: object;
-    originalErr?: boolean;
-}
-
-interface DeleteQueryOptions extends QueryOptions {
-    response?: "default" | "none" | 'all_old';
-}
-
-interface PutQueryOptions extends QueryOptions {
-    response?: "default" | "none" | 'all_old';
-}
-
-interface ParamOptions {
-    params?: object;
-    table?: string;
-    limit?: number;
-    response?: "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
-}
-
-interface PaginationOptions extends QueryOptions {
-    pager?: "raw" | "item" | "named";
-    limit?: number;
-}
-
-interface BulkOptions extends QueryOptions {
-    unprocessed?: "raw" | "item";
-    concurrency?: number;
-    preserveBatchOrder?: boolean;
-}
-
-type OptionalDefaultEntityIdentifiers = {
-    __edb_e__?: string;
-    __edb_v__?: string;
-}
-
-type GoRecord<ResponseType, Options = QueryOptions> = <T = ResponseType>(options?: Options) => Promise<T>;
-
-type BatchGoRecord<ResponseType, AlternateResponseType> = <O extends BulkOptions>(options?: O) =>
-    O extends infer Options
-        ? 'preserveBatchOrder' extends keyof Options
-        ? Options['preserveBatchOrder'] extends true
-            ? Promise<AlternateResponseType>
-            : Promise<ResponseType>
-        : Promise<ResponseType>
-        : never
-
-type PageRecord<ResponseType, CompositeAttributes> = (page?: (CompositeAttributes & OptionalDefaultEntityIdentifiers) | null, options?: PaginationOptions) => Promise<[
-    (CompositeAttributes & OptionalDefaultEntityIdentifiers) | null,
-    ResponseType
-]>;
-
-type ParamRecord<Options = ParamOptions> = <P>(options?: Options) => P;
-
-type RecordsActionOptions<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, Items, IndexCompositeAttributes> = {
-    go: GoRecord<Items>;
-    params: ParamRecord;
-    page: PageRecord<Items,IndexCompositeAttributes>;
-    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,RecordsActionOptions<A,F,C,S,Items,IndexCompositeAttributes>>;
-}
-
-type SingleRecordOperationOptions<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, ResponseType> = {
-    go: GoRecord<ResponseType, QueryOptions>;
-    params: ParamRecord<QueryOptions>;
-    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,SingleRecordOperationOptions<A,F,C,S,ResponseType>>;
-};
-
-type PutRecordOperationOptions<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, ResponseType> = {
-    go: GoRecord<ResponseType, PutQueryOptions>;
-    params: ParamRecord<PutQueryOptions>;
-    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,PutRecordOperationOptions<A,F,C,S,ResponseType>>;
-};
-
-type UpdateRecordOperationOptions<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, ResponseType> = {
-    go: GoRecord<ResponseType, UpdateQueryOptions>;
-    params: ParamRecord<UpdateQueryParams>;
-    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,PutRecordOperationOptions<A,F,C,S,ResponseType>>;
-};
-
-type DeleteRecordOperationOptions<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, ResponseType> = {
-    go: GoRecord<ResponseType, DeleteQueryOptions>;
-    params: ParamRecord<DeleteQueryOptions>;
-    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,DeleteRecordOperationOptions<A,F,C,S,ResponseType>>;
-};
-
-type BulkRecordOperationOptions<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, ResponseType, AlternateResponseType> = {
-    go: BatchGoRecord<ResponseType, AlternateResponseType>;
-    params: ParamRecord<BulkOptions>;
-};
-
-type SetRecordActionOptions<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, SetAttr,IndexCompositeAttributes,TableItem> = {
-    go: GoRecord<Partial<TableItem>, UpdateQueryOptions>;
-    params: ParamRecord<UpdateQueryParams>;
-    set: SetRecord<A,F,C,S, SetItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
-    remove: SetRecord<A,F,C,S, Array<keyof SetItem<A,F,C,S>>,IndexCompositeAttributes,TableItem>;
-    add: SetRecord<A,F,C,S, AddItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
-    subtract: SetRecord<A,F,C,S, SubtractItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
-    append: SetRecord<A,F,C,S, AppendItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
-    delete: SetRecord<A,F,C,S, DeleteItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
-    data: DataUpdateMethodRecord<A,F,C,S, Item<A,F,C,S,S["attributes"]>,IndexCompositeAttributes,TableItem>;
-    where: WhereClause<A,F,C,S, Item<A,F,C,S,S["attributes"]>,SetRecordActionOptions<A,F,C,S,SetAttr,IndexCompositeAttributes,TableItem>>;
-}
-
-type SetRecord<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, SetAttr, IndexCompositeAttributes, TableItem> = (properties: SetAttr) => SetRecordActionOptions<A,F,C,S, SetAttr, IndexCompositeAttributes, TableItem>;
-type RemoveRecord<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, RemoveAttr, IndexCompositeAttributes, TableItem> = (properties: RemoveAttr) => SetRecordActionOptions<A,F,C,S, RemoveAttr, IndexCompositeAttributes, TableItem>;
-type DataUpdateMethodRecord<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, SetAttr, IndexCompositeAttributes, TableItem> =
-    DataUpdateMethod<A,F,C,S, UpdateData<A,F,C,S>, SetRecordActionOptions<A,F,C,S, SetAttr, IndexCompositeAttributes, TableItem>>
-
-type WhereClause<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends Item<A,F,C,S,S["attributes"]>, T> = (where: WhereCallback<A,F,C,S,I>) => T;
-
-type DataUpdateMethod<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends UpdateData<A,F,C,S>, T> = (update: DataUpdateCallback<A,F,C,S,I>) => T;
-
-type QueryOperations<A extends string, F extends A, C extends string, S extends Schema<A,F,C>, CompositeAttributes, TableItem, IndexCompositeAttributes> = {
-    between: (skCompositeAttributesStart: CompositeAttributes, skCompositeAttributesEnd: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
-    gt: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
-    gte: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
-    lt: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
-    lte: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
-    begins: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
-    go: GoRecord<Array<TableItem>>;
-    params: ParamRecord;
-    page: PageRecord<Array<TableItem>,IndexCompositeAttributes>;
-    where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,RecordsActionOptions<A,F,C,S,Array<TableItem>,IndexCompositeAttributes>>
-}
-
-type Queries<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> = {
-    [I in keyof S["indexes"]]: <CompositeAttributes extends IndexCompositeAttributes<A,F,C,S,I>>(composite: CompositeAttributes) =>
-        IndexSKAttributes<A,F,C,S,I> extends infer SK
-            // If there is no SK, dont show query operations (when an empty array is provided)
-            ? [keyof SK] extends [never]
-                ? RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S> & Required<CompositeAttributes>>
-                // If there is no SK, dont show query operations (When no PK is specified)
-                : S["indexes"][I] extends IndexWithSortKey
-                    ? QueryOperations<
-                        A,F,C,S,
-                        // Omit the composite attributes already provided
-                        Omit<Partial<IndexSKAttributes<A,F,C,S,I>>, keyof CompositeAttributes>,
-                        ResponseItem<A,F,C,S>,
-                        AllTableIndexCompositeAttributes<A,F,C,S> & Required<CompositeAttributes> & SK
-                        >
-                    : RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S> & Required<CompositeAttributes> & SK>
-            : never
-}
-
-type DocumentClientMethod = (parameters: any) => {promise: () => Promise<any>};
-
-type DocumentClient = {
-    get: DocumentClientMethod;
-    put: DocumentClientMethod;
-    delete: DocumentClientMethod;
-    update: DocumentClientMethod;
-    batchWrite: DocumentClientMethod;
-    batchGet: DocumentClientMethod;
-    scan: DocumentClientMethod;
-    transactGet: DocumentClientMethod;
-    transactWrite: DocumentClientMethod;
-} | {
-    send: (command: any) => Promise<any>;
-}
-
-type ElectroDBMethodTypes = "put" | "get" | "query" | "scan" | "update" | "delete" | "remove" | "patch" | "create" | "batchGet" | "batchWrite";
-
-interface ElectroQueryEvent<P extends any = any> {
-    type: 'query';
-    method: ElectroDBMethodTypes;
-    config: any;
-    params: P;
-}
-
-interface ElectroResultsEvent<R extends any = any> {
-    type: 'results';
-    method: ElectroDBMethodTypes;
-    config: any;
-    results: R;
-    success: boolean;
+    add: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: A extends DataUpdateAttributeSymbol<infer V> ? V extends number | Array<any> ? V : [V] extends [any] ? V : never : never ) => any;
+    subtract: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: A extends DataUpdateAttributeSymbol<infer V> ? V extends number ? V : [V] extends [any] ? V : never : never ) => any;
+    delete: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: A extends DataUpdateAttributeSymbol<infer V> ? V extends Array<any> ? V : [V] extends [any] ? V : never : never ) => any;
+    del:    <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: A extends DataUpdateAttributeSymbol<infer V> ? V extends Array<any> ? V : never : never ) => any;
+    value: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: DataUpdateAttributeValues<A>) => Required<DataUpdateAttributeValues<A>>;
+    name: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A) => any;
+    ifNotExists: <T, A extends DataUpdateAttributeSymbol<T>>(attr: A, value: DataUpdateAttributeValues<A>) => any;
 }
 
-type ElectroEvent = 
-    ElectroQueryEvent
-    | ElectroResultsEvent;
+export type WhereCallback<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends Item<A,F,C,S,S["attributes"]>> =
+    <W extends WhereAttributes<A,F,C,S,I>>(attributes: W, operations: WhereOperations<A,F,C,S,I>) => string;
 
-type ElectroEventType = Pick<ElectroEvent, 'type'>;
+export type DataUpdateCallback<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends UpdateData<A,F,C,S>> =
+    <W extends DataUpdateAttributes<A,F,C,S,I>>(attributes: W, operations: DataUpdateOperations<A,F,C,S,I>) => any;
 
-type EventListener = (event: ElectroEvent) => void;
+export type WhereClause<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends Item<A,F,C,S,S["attributes"]>, T> = (where: WhereCallback<A,F,C,S,I>) => T;
 
-// todo: coming soon, more events!
-// | {
-//     name: "error";
-//     type: "configuration_error" | "invalid_query" | "dynamodb_client";
-//     message: string;
-//     details: ElectroError;
-// } | {
-//     name: "error";
-//     type: "user_defined";
-//     message: string;
-//     details: ElectroValidationError;
-// } | {
-//     name: "warn";
-//     type: "deprecation_warning" | "optimization_suggestion";
-//     message: string;
-//     details: any;
-// } | {
-//     name: "info";
-//     type: "client_updated" | "table_overwritten";
-//     message: string;
-//     details: any;
-// };
+export type DataUpdateMethod<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends UpdateData<A,F,C,S>, T> = (update: DataUpdateCallback<A,F,C,S,I>) => T;
 
-type EntityConfiguration = {
-    table?: string;
-    client?: DocumentClient;
-    listeners?: Array<EventListener>;
-    logger?: EventListener;
-};
+type Resolve<T> = T extends Function | string | number | boolean
+    ? T : {[Key in keyof T]: Resolve<T[Key]>}
 
-type ServiceConfiguration = {
+export type EntityConfiguration = {
     table?: string;
     client?: DocumentClient;
-    listeners?: Array<EventListener>;
-    logger?: EventListener;
+    listeners?: Array<ElectroEventListener>;
+    logger?: ElectroEventListener;
 };
 
-type ParseSingleInput = {
-    Item?: {[key: string]: any}
-} | {
-    Attributes?: {[key: string]: any}
-} | null;
-
-type ParseMultiInput = {
-    Items?: {[key: string]: any}[]
-}
-
-export class Entity<A extends string, F extends A, C extends string, S extends Schema<A,F,C>> {
+export class Entity<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> {
     readonly schema: S;
+    private config?: EntityConfiguration;
     constructor(schema: S, config?: EntityConfiguration);
+
     get(key: AllTableIndexCompositeAttributes<A,F,C,S>): SingleRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S> | null>;
-    get(key: AllTableIndexCompositeAttributes<A,F,C,S>[]): BulkRecordOperationOptions<A,F,C,S, [Array<Flatten<ResponseItem<A,F,C,S>>>, Array<Flatten<AllTableIndexCompositeAttributes<A,F,C,S>>>], [Array<Flatten<ResponseItem<A,F,C,S>> | null>, Array<Flatten<AllTableIndexCompositeAttributes<A,F,C,S>>>]>;
+    get(key: AllTableIndexCompositeAttributes<A,F,C,S>[]): BulkRecordOperationOptions<A,F,C,S, [Array<Resolve<ResponseItem<A,F,C,S>>>, Array<Resolve<AllTableIndexCompositeAttributes<A,F,C,S>>>], [Array<Resolve<ResponseItem<A,F,C,S>> | null>, Array<Resolve<AllTableIndexCompositeAttributes<A,F,C,S>>>]>;
+
     delete(key: AllTableIndexCompositeAttributes<A,F,C,S>): DeleteRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S>>;
     delete(key: AllTableIndexCompositeAttributes<A,F,C,S>[]): BulkRecordOperationOptions<A,F,C,S, AllTableIndexCompositeAttributes<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S>[]>;
-    remove(key: AllTableIndexCompositeAttributes<A,F,C,S>): DeleteRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S>>;
+
+    put(record: PutItem<A,F,C,S>): PutRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S>>;
+    put(record: PutItem<A,F,C,S>[]): BulkRecordOperationOptions<A,F,C,S, AllTableIndexCompositeAttributes<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S>[]>;
+
+    remove(key: AllTableIndexCompositeAttributes<A,F,C,S>): DeleteRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S>>
     update(key: AllTableIndexCompositeAttributes<A,F,C,S>): {
         set: SetRecord<A,F,C,S, SetItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
         remove: RemoveRecord<A,F,C,S, RemoveItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
@@ -1244,6 +1651,7 @@ export class Entity<A extends string, F extends A, C extends string, S extends S
         delete: SetRecord<A,F,C,S, DeleteItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
         data: DataUpdateMethodRecord<A,F,C,S, Item<A,F,C,S,S["attributes"]>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
     };
+
     patch(key: AllTableIndexCompositeAttributes<A,F,C,S>): {
         set: SetRecord<A,F,C,S, SetItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
         remove: RemoveRecord<A,F,C,S, RemoveItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
@@ -1253,309 +1661,31 @@ export class Entity<A extends string, F extends A, C extends string, S extends S
         delete: SetRecord<A,F,C,S, DeleteItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
         data: DataUpdateMethodRecord<A,F,C,S, Item<A,F,C,S,S["attributes"]>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
     };
-    put(record: PutItem<A,F,C,S>): PutRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S>>;
-    put(record: PutItem<A,F,C,S>[]): BulkRecordOperationOptions<A,F,C,S, AllTableIndexCompositeAttributes<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S>[]>;
-    create(record: PutItem<A,F,C,S>): PutRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S>>;
+
+    create(record: PutItem<A,F,C,S>): PutRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S>>
+
     find(record: Partial<Item<A,F,C,S,S["attributes"]>>): RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S>>;
+
     match(record: Partial<Item<A,F,C,S,S["attributes"]>>): RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S>>;
-    scan: RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], TableIndexCompositeAttributes<A,F,C,S>>
+
+    scan: RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], TableIndexCompositeAttributes<A,F,C,S>>;
     query: Queries<A,F,C,S>;
+
     parse(item: ParseSingleInput, options?: ParseOptions): ResponseItem<A,F,C,S> | null;
     parse(item: ParseMultiInput, options?: ParseOptions): ResponseItem<A,F,C,S>[];
     setIdentifier(type: "entity" | "version", value: string): void;
     client: any;
 }
 
-type AllCollectionNames<E extends {[name: string]: Entity<any, any, any, any>}> = {
-    [Name in keyof E]:
-    E[Name] extends Entity<infer A, infer F, infer C, infer S>
-        ? {
-            [Collection in keyof EntityCollections<A,F,C,S>]: Collection
-        }[keyof EntityCollections<A,F,C,S>]
-        : never
-}[keyof E];
-
-type AllEntityAttributeNames<E extends {[name: string]: Entity<any, any, any, any>}> = {
-    [Name in keyof E]: {
-        [A in keyof E[Name]["schema"]["attributes"]]: A
-    }[keyof E[Name]["schema"]["attributes"]]
-}[keyof E];
-
-type AllEntityAttributes<E extends {[name: string]: Entity<any, any, any, any>}> = {
-    [Attr in AllEntityAttributeNames<E>]: {
-        [Name in keyof E]: Attr extends keyof E[Name]["schema"]["attributes"]
-            ? ItemAttribute<E[Name]["schema"]["attributes"][Attr]>
-            : never
-    }[keyof E];
+export type ServiceConfiguration = {
+    table?: string;
+    client?: DocumentClient;
+    listeners?: Array<ElectroEventListener>;
+    logger?: ElectroEventListener;
 };
 
-type CollectionAssociations<E extends {[name: string]: Entity<any, any, any, any>}> = {
-    [Collection in AllCollectionNames<E>]: {
-        [Name in keyof E]: E[Name] extends Entity<infer A, infer F, infer C, infer S>
-            ? Collection extends keyof EntityCollections<A,F,C,S>
-                ? Name
-                : never
-            : never
-    }[keyof E];
-}
-
-type CollectionAttributes<E extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<E>> = {
-    [Collection in keyof Collections]: {
-        [EntityName in keyof E]: E[EntityName] extends Entity<infer A, infer F, infer C, infer S>
-            ? EntityName extends Collections[Collection]
-                ? keyof S["attributes"]
-                : never
-            : never
-    }[keyof E]
-}
-
-type CollectionWhereOperations = {
-    eq: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-    ne: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-    gt: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-    lt: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-    gte: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-    lte: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-    between: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T, value2: T) => string;
-    begins: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-    exists: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
-    notExists: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
-    contains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-    notContains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-    value: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-    name: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
-}
-
-type CollectionWhereCallback<E extends {[name: string]: Entity<any, any, any, any>}, I extends Partial<AllEntityAttributes<E>>> =
-    <W extends {[A in keyof I]: WhereAttributeSymbol<I[A]>}>(attributes: W, operations: CollectionWhereOperations) => string;
-
-type CollectionWhereClause<E extends {[name: string]: Entity<any, any, any, any>}, A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends Partial<AllEntityAttributes<E>>, T> = (where: CollectionWhereCallback<E, I>) => T;
-
-type WhereRecordsActionOptions<E extends {[name: string]: Entity<any, any, any, any>}, A extends string, F extends A, C extends string, S extends Schema<A,F,C>, I extends Partial<AllEntityAttributes<E>>, Items, IndexCompositeAttributes> = {
-    go: GoRecord<Items>;
-    params: ParamRecord;
-    page: PageRecord<Items,IndexCompositeAttributes>;
-    where: CollectionWhereClause<E,A,F,C,S,I, WhereRecordsActionOptions<E,A,F,C,S,I,Items,IndexCompositeAttributes>>;
-}
-
-type CollectionIndexKeys<Entities extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<Entities>> = {
-    [Collection in keyof Collections]: {
-        [EntityResultName in Collections[Collection]]:
-            EntityResultName extends keyof Entities
-                ? Entities[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
-                    ? keyof TableIndexCompositeAttributes<A, F, C, S>
-                    : never
-                : never
-    }[Collections[Collection]]
-}
-
-type CollectionPageKeys<Entities extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<Entities>> = {
-    [Collection in keyof Collections]: {
-        [EntityResultName in Collections[Collection]]:
-            EntityResultName extends keyof Entities
-                ? Entities[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
-                    ? keyof Parameters<Entities[EntityResultName]["query"][
-                        Collection extends keyof EntityCollections<A,F,C,S>
-                            ? EntityCollections<A,F,C,S>[Collection]
-                            : never
-                    ]>[0]
-                    : never
-                : never
-    }[Collections[Collection]]
-}
-
-type CollectionIndexAttributes<Entities extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<Entities>> = {
-    [Collection in keyof CollectionIndexKeys<Entities, Collections>]: {
-        [key in CollectionIndexKeys<Entities, Collections>[Collection]]:
-            key extends keyof AllEntityAttributes<Entities>
-                ? AllEntityAttributes<Entities>[key]
-                : never
-    }
-}
-
-type CollectionPageAttributes<Entities extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<Entities>> = {
-    [Collection in keyof CollectionPageKeys<Entities, Collections>]: {
-        [key in CollectionPageKeys<Entities, Collections>[Collection]]:
-            key extends keyof AllEntityAttributes<Entities>
-                ? AllEntityAttributes<Entities>[key]
-                : never
-    }
-}
-
-type OptionalPropertyNames<T> =
-    { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T];
-
-// Common properties from L and R with undefined in R[K] replaced by type in L[K]
-type SpreadProperties<L, R, K extends keyof L & keyof R> =
-    { [P in K]: L[P] | Exclude<R[P], undefined> };
-
-type Id<T> = {[K in keyof T]: T[K]} // see note at bottom*
-
-// Type of { ...L, ...R }
-type Spread<L, R> = Id<
-    // Properties in L that don't exist in R
-    & Pick<L, Exclude<keyof L, keyof R>>
-    // Properties in R with types that exclude undefined
-    & Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>>
-    // Properties in R, with types that include undefined, that don't exist in L
-    & Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>>
-    // Properties in R, with types that include undefined, that exist in L
-    & SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>
-    >;
-
-
-
-type CollectionQueries<E extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<E>> = {
-    [Collection in keyof Collections]: {
-        [EntityName in keyof E]:
-            EntityName extends Collections[Collection]
-                ? (params:
-                       RequiredProperties<
-                           Parameters<
-                               E[EntityName]["query"][
-                                   E[EntityName] extends Entity<infer A, infer F, infer C, infer S>
-                                       ? Collection extends keyof EntityCollections<A,F,C,S>
-                                        ? EntityCollections<A,F,C,S>[Collection]
-                                        : never
-                                       : never
-                               ]
-                           >[0]
-                       >) => {
-                    go: GoRecord<{
-                        [EntityResultName in Collections[Collection]]:
-                            EntityResultName extends keyof E
-                                ? E[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
-                                    ? ResponseItem<A,F,C,S>[]
-                                    : never
-                                : never
-                    }>;
-                    params: ParamRecord;
-                    page: {
-                        [EntityResultName in Collections[Collection]]: EntityResultName extends keyof E
-                            ? Pick<AllEntityAttributes<E>, Extract<AllEntityAttributeNames<E>, CollectionAttributes<E,Collections>[Collection]>> extends Partial<AllEntityAttributes<E>>
-                                ?
-                                    PageRecord<
-                                        {
-                                            [EntityResultName in Collections[Collection]]:
-                                            EntityResultName extends keyof E
-                                                ? E[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
-                                                    ? ResponseItem<A,F,C,S>[]
-                                                    : never
-                                                : never
-                                        },
-                                        Partial<
-                                            Spread<
-                                                Collection extends keyof CollectionPageAttributes<E, Collections>
-                                                    ? CollectionPageAttributes<E, Collections>[Collection]
-                                                    : {},
-                                                Collection extends keyof CollectionIndexAttributes<E, Collections>
-                                                    ? CollectionIndexAttributes<E, Collections>[Collection]
-                                                    : {}
-                                            >
-                                        >
-                                    >
-                                : never
-                            : never
-                    }[Collections[Collection]];
-                    where: {
-                        [EntityResultName in Collections[Collection]]: EntityResultName extends keyof E
-                                ? E[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
-                                    ? Pick<AllEntityAttributes<E>, Extract<AllEntityAttributeNames<E>, CollectionAttributes<E,Collections>[Collection]>> extends Partial<AllEntityAttributes<E>>
-                                        ? CollectionWhereClause<E,A,F,C,S,
-                                            Pick<AllEntityAttributes<E>, Extract<AllEntityAttributeNames<E>, CollectionAttributes<E,Collections>[Collection]>>,
-                                            WhereRecordsActionOptions<E,A,F,C,S,
-                                                Pick<AllEntityAttributes<E>, Extract<AllEntityAttributeNames<E>, CollectionAttributes<E,Collections>[Collection]>>,
-                                                    {
-                                                        [EntityResultName in Collections[Collection]]:
-                                                            EntityResultName extends keyof E
-                                                                ? E[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
-                                                                    ? ResponseItem<A,F,C,S>[]
-                                                                    : never
-                                                                : never
-                                                    },
-                                                    Partial<
-                                                        Spread<
-                                                            Collection extends keyof CollectionPageAttributes<E, Collections>
-                                                                ? CollectionPageAttributes<E, Collections>[Collection]
-                                                                : {},
-                                                            Collection extends keyof CollectionIndexAttributes<E, Collections>
-                                                                ? CollectionIndexAttributes<E, Collections>[Collection]
-                                                                : {}
-                                                            >
-                                                    >
-                                                >>
-                                        : never
-                                    : never
-                                : never
-                    }[Collections[Collection]];
-                }
-                : never
-    }[keyof E];
-}
-
-type RequiredProperties<T> = Pick<T, {[K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T]>
-
 export class Service<E extends {[name: string]: Entity<any, any, any, any>}> {
     entities: E;
     collections: CollectionQueries<E, CollectionAssociations<E>>
     constructor(entities: E, config?: ServiceConfiguration);
-}
-
-export type EntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? ResponseItem<A, F, C, S>
-        : never;
-
-export type CreateEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? PutItem<A, F, C, S>
-        : never;
-
-export type UpdateEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? Partial<ResponseItem<A,F,C,S>>
-        : never;
-
-export type UpdateAddEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? AddItem<A, F, C, S>
-        : never;
-
-export type UpdateSubtractEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? SubtractItem<A, F, C, S>
-        : never;
-
-export type UpdateAppendEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? AppendItem<A, F, C, S>
-        : never;
-
-export type UpdateRemoveEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? RemoveItem<A, F, C, S>
-        : never;
-
-export type UpdateDeleteEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? DeleteItem<A, F, C, S>
-        : never;
-
-export type EntityRecord<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? Item<A,F,C,S,S["attributes"]>
-        : never;
-
-export type CollectionItem<SERVICE extends Service<any>, COLLECTION extends keyof SERVICE["collections"]> =
-    SERVICE extends Service<infer E> ? Pick<{
-        [EntityName in keyof E]: E[EntityName] extends Entity<infer A, infer F, infer C, infer S>
-            ? COLLECTION extends keyof CollectionAssociations<E>
-                ? EntityName extends CollectionAssociations<E>[COLLECTION]
-                    ? ResponseItem<A,F,C,S>[]
-                    : never
-                : never
-            : never
-        }, COLLECTION extends keyof CollectionAssociations<E>
-            ? CollectionAssociations<E>[COLLECTION]
-            : never>
-    : never
+}