@carbonorm/carbonnode 3.0.3 → 3.0.5

package/dist/api/convertForRequestBody.d.ts

@@ -1,4 +1,8 @@
-import { iC6Object } from "./types/ormInterfaces";
-export default function <RestTableInterfaces extends {
+import { iC6Object, iRestMethods, RequestQueryBody } from "./types/ormInterfaces";
+export default function <RequestMethod extends iRestMethods, RestTableInterface extends {
     [key: string]: any;
-}>(restfulObject: RestTableInterfaces, tableName: string | string[], C6: iC6Object, regexErrorHandler?: (message: string) => void): {};
+}, CustomAndRequiredFields extends {
+    [key: string]: any;
+} = {}, RequestTableOverrides extends {
+    [K in keyof RestTableInterface]?: any;
+} = {}>(restfulObject: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>, tableName: string | string[], C6: iC6Object, regexErrorHandler?: (message: string) => void): {};

package/dist/api/executors/Executor.d.ts

@@ -1,5 +1,4 @@
-import { apiReturn, DetermineResponseDataType, iAPI, iRest, iRestMethods, iRestReactiveLifecycle } from "@carbonorm/carbonnode";
-import { Modify } from "../types/modifyTypes";
+import { apiReturn, DetermineResponseDataType, iRest, iRestMethods, iRestReactiveLifecycle, RequestQueryBody } from "@carbonorm/carbonnode";
 export declare abstract class Executor<RequestMethod extends iRestMethods, RestShortTableName extends string = any, RestTableInterface extends {
     [key: string]: any;
 } = any, PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>, CustomAndRequiredFields extends {
@@ -10,8 +9,8 @@ export declare abstract class Executor<RequestMethod extends iRestMethods, RestS
     [key in keyof RestTableInterface]: any;
 }> {
     protected config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
-    protected request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields;
-    constructor(config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>, request?: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields);
+    protected request: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
+    constructor(config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>, request: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>);
     abstract execute(): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>>;
     runLifecycleHooks<Phase extends keyof iRestReactiveLifecycle<RequestMethod, RestShortTableName, RestTableInterface, PrimaryKey, CustomAndRequiredFields, RequestTableOverrides>>(phase: Phase, args: Parameters<NonNullable<iRestReactiveLifecycle<RequestMethod, RestShortTableName, RestTableInterface, PrimaryKey, CustomAndRequiredFields, RequestTableOverrides>[Phase]>[string]>[0]): Promise<void>;
 }

package/dist/api/executors/HttpExecutor.d.ts

@@ -1,6 +1,5 @@
 import { AxiosResponse } from "axios";
-import { Modify } from "../types/modifyTypes";
-import { apiReturn, DetermineResponseDataType, iAPI, iRestMethods } from "../types/ormInterfaces";
+import { apiReturn, DetermineResponseDataType, iRestMethods, RequestQueryBody } from "../types/ormInterfaces";
 import { Executor } from "./Executor";
 export declare class HttpExecutor<RequestMethod extends iRestMethods, RestShortTableName extends string = any, RestTableInterface extends {
     [key: string]: any;
@@ -11,8 +10,8 @@ export declare class HttpExecutor<RequestMethod extends iRestMethods, RestShortT
 } = {
     [key in keyof RestTableInterface]: any;
 }> extends Executor<RequestMethod, RestShortTableName, RestTableInterface, PrimaryKey, CustomAndRequiredFields, RequestTableOverrides> {
-    putState(response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>, request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields, callback: () => void): void;
-    postState(response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>, request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields, callback: () => void): void;
-    deleteState(_response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>, request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields, callback: () => void): void;
+    putState(response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>, request: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>, callback: () => void): void;
+    postState(response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>, request: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>, callback: () => void): void;
+    deleteState(_response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>, request: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>, callback: () => void): void;
     execute(): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>>;
 }

package/dist/api/restOrm.d.ts

@@ -8,36 +8,8 @@ export declare function restOrm<RestShortTableName extends string = any, RestTab
 } = {
     [key in keyof RestTableInterface]: any;
 }>(config: Omit<iRest<RestShortTableName, RestTableInterface, PrimaryKey>, "requestMethod">): {
-    Get: (request?: Omit<RestTableInterface, keyof RequestTableOverrides> & RequestTableOverrides & {
-        dataInsertMultipleRows?: import("..").Modify<RestTableInterface, RequestTableOverrides>[] | undefined;
-        cacheResults?: boolean;
-        fetchDependencies?: number | import("..").eFetchDependencies | Awaited<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iGetC6RestResponse<any>>>[];
-        debug?: boolean;
-        success?: string | ((r: import("axios").AxiosResponse) => (string | void));
-        error?: string | ((r: import("axios").AxiosResponse) => (string | void));
-    } & CustomAndRequiredFields) => Promise<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iGetC6RestResponse<RestTableInterface, {}>>>;
-    Put: (request?: Omit<RestTableInterface, keyof RequestTableOverrides> & RequestTableOverrides & {
-        dataInsertMultipleRows?: import("..").Modify<RestTableInterface, RequestTableOverrides>[] | undefined;
-        cacheResults?: boolean;
-        fetchDependencies?: number | import("..").eFetchDependencies | Awaited<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iGetC6RestResponse<any>>>[];
-        debug?: boolean;
-        success?: string | ((r: import("axios").AxiosResponse) => (string | void));
-        error?: string | ((r: import("axios").AxiosResponse) => (string | void));
-    } & CustomAndRequiredFields) => Promise<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iPutC6RestResponse<RestTableInterface, any>>>;
-    Post: (request?: Omit<RestTableInterface, keyof RequestTableOverrides> & RequestTableOverrides & {
-        dataInsertMultipleRows?: import("..").Modify<RestTableInterface, RequestTableOverrides>[] | undefined;
-        cacheResults?: boolean;
-        fetchDependencies?: number | import("..").eFetchDependencies | Awaited<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iGetC6RestResponse<any>>>[];
-        debug?: boolean;
-        success?: string | ((r: import("axios").AxiosResponse) => (string | void));
-        error?: string | ((r: import("axios").AxiosResponse) => (string | void));
-    } & CustomAndRequiredFields) => Promise<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iPostC6RestResponse<RestTableInterface>>>;
-    Delete: (request?: Omit<RestTableInterface, keyof RequestTableOverrides> & RequestTableOverrides & {
-        dataInsertMultipleRows?: import("..").Modify<RestTableInterface, RequestTableOverrides>[] | undefined;
-        cacheResults?: boolean;
-        fetchDependencies?: number | import("..").eFetchDependencies | Awaited<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iGetC6RestResponse<any>>>[];
-        debug?: boolean;
-        success?: string | ((r: import("axios").AxiosResponse) => (string | void));
-        error?: string | ((r: import("axios").AxiosResponse) => (string | void));
-    } & CustomAndRequiredFields) => Promise<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iDeleteC6RestResponse<RestTableInterface, any>>>;
+    Get: (request: import("./types/ormInterfaces").iAPI<import("./types/ormInterfaces").RequestGetPutDeleteBody<Omit<RestTableInterface, keyof RequestTableOverrides> & RequestTableOverrides & CustomAndRequiredFields>>) => Promise<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iGetC6RestResponse<RestTableInterface, {}>>>;
+    Put: (request: import("./types/ormInterfaces").iAPI<import("./types/ormInterfaces").RequestGetPutDeleteBody<Omit<RestTableInterface, keyof RequestTableOverrides> & RequestTableOverrides & CustomAndRequiredFields>>) => Promise<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iPutC6RestResponse<RestTableInterface, any>>>;
+    Post: (request: import("./types/ormInterfaces").iAPI<Omit<RestTableInterface, keyof RequestTableOverrides> & RequestTableOverrides & CustomAndRequiredFields>) => Promise<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iPostC6RestResponse<RestTableInterface>>>;
+    Delete: (request: import("./types/ormInterfaces").iAPI<import("./types/ormInterfaces").RequestGetPutDeleteBody<Omit<RestTableInterface, keyof RequestTableOverrides> & RequestTableOverrides & CustomAndRequiredFields>>) => Promise<import("./types/ormInterfaces").apiReturn<import("./types/ormInterfaces").iDeleteC6RestResponse<RestTableInterface, any>>>;
 };

package/dist/api/restRequest.d.ts

@@ -1,5 +1,4 @@
-import { Modify } from "./types/modifyTypes";
-import { apiReturn, DetermineResponseDataType, iAPI, iRest, iRestMethods } from "./types/ormInterfaces";
+import { apiReturn, DetermineResponseDataType, iRest, iRestMethods, RequestQueryBody } from "./types/ormInterfaces";
 /**
  * Facade: routes API calls to SQL or HTTP executors based on runtime context.
  */
@@ -11,4 +10,4 @@ export default function restRequest<RequestMethod extends iRestMethods, RestShor
     [key in keyof RestTableInterface]: any;
 } = {
     [key in keyof RestTableInterface]: any;
-}>(config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>): (request?: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields) => Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>>;
+}>(config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>): (request: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>) => Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>>;

package/dist/api/types/ormInterfaces.d.ts

@@ -4,6 +4,11 @@ import { eFetchDependencies } from "./dynamicFetching";
 import { Modify } from "./modifyTypes";
 import { JoinType, OrderDirection, SQLComparisonOperator, SQLFunction } from "./mysqlTypes";
 import { CarbonReact } from "@carbonorm/carbonreact";
+export type iRestMethods = 'GET' | 'POST' | 'PUT' | 'DELETE';
+export declare const POST = "POST";
+export declare const PUT = "PUT";
+export declare const GET = "GET";
+export declare const DELETE = "DELETE";
 export interface stringMap {
     [key: string]: string;
 }
@@ -22,53 +27,103 @@ export interface iTypeValidation {
     AUTO_INCREMENT: boolean;
     SKIP_COLUMN_IN_POST: boolean;
 }
-export type iRestReactiveLifecycle<RequestMethod extends iRestMethods, RestShortTableName extends string = any, RestTableInterface extends {
+export type SubSelect<T extends {
     [key: string]: any;
-} = any, PrimaryKey extends keyof RestTableInterface & string = any, CustomAndRequiredFields extends {
+} = any> = {
+    subSelect: true;
+    table: string;
+    args: RequestQueryBody<'GET', T>;
+    alias: string;
+};
+export type SelectField<T extends {
     [key: string]: any;
-} = any, RequestTableOverrides extends {
+} = any> = keyof T | [keyof T, 'AS', string] | [SQLFunction, keyof T] | [SQLFunction, keyof T, string] | SubSelect<T>;
+export type WhereClause<T = any> = Partial<T> | LogicalGroup<T> | ComparisonClause<T>;
+export type LogicalGroup<T = any> = {
+    [logicalGroup: string]: Array<WhereClause<T>>;
+};
+export type ComparisonClause<T = any> = [keyof T, SQLComparisonOperator, any];
+export type JoinTableCondition<T = any> = Partial<T> | WhereClause<T>[] | ComparisonClause<T>[];
+export type JoinClause<T = any> = {
+    [table: string]: JoinTableCondition<T>;
+};
+export type Join<T = any> = {
+    [K in JoinType]?: JoinClause<T>;
+};
+export type Pagination<T = any> = {
+    PAGE?: number;
+    LIMIT?: number | null;
+    ORDER?: Partial<Record<keyof T, OrderDirection>>;
+};
+export type RequestGetPutDeleteBody<T extends {
     [key: string]: any;
-} = {
-    [key in keyof RestTableInterface]: any;
-}> = {
-    beforeProcessing?: {
-        [key: string]: (args: {
-            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
-            request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields;
-        }) => void | Promise<void>;
-    };
-    beforeExecution?: {
-        [key: string]: (args: {
-            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
-            request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields;
-        }) => void | Promise<void>;
-    };
-    afterExecution?: {
-        [key: string]: (args: {
-            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
-            request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields;
-            response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
-        }) => void | Promise<void>;
-    };
-    afterCommit?: {
-        [key: string]: (args: {
-            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
-            request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields;
-            response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
-        }) => void | Promise<void>;
-    };
+} = any> = {
+    SELECT?: SelectField<T>[];
+    UPDATE?: Partial<T>;
+    DELETE?: boolean;
+    WHERE?: WhereClause<T>;
+    JOIN?: Join<T>;
+    PAGINATION?: Pagination<T>;
 };
-export type iRestHooks<RestShortTableName extends string = any, RestTableInterface extends {
+export type iAPI<T extends {
     [key: string]: any;
-} = any, PrimaryKey extends keyof RestTableInterface & string = any, CustomAndRequiredFields extends {
+}> = T & {
+    dataInsertMultipleRows?: T[];
+    cacheResults?: boolean;
+    fetchDependencies?: number | eFetchDependencies | Awaited<apiReturn<iGetC6RestResponse<any>>>[];
+    debug?: boolean;
+    success?: string | ((r: AxiosResponse) => string | void);
+    error?: string | ((r: AxiosResponse) => string | void);
+};
+export type RequestQueryBody<Method extends iRestMethods, T extends {
     [key: string]: any;
-} = any, RequestTableOverrides extends {
+}, Custom extends {
     [key: string]: any;
-} = {
-    [key in keyof RestTableInterface]: any;
-}> = {
-    [Method in iRestMethods]: iRestReactiveLifecycle<Method, RestShortTableName, RestTableInterface, PrimaryKey, CustomAndRequiredFields, RequestTableOverrides>;
-};
+} = {}, Overrides extends {
+    [key: string]: any;
+} = {}> = Method extends 'GET' | 'PUT' | 'DELETE' ? iAPI<RequestGetPutDeleteBody<Modify<T, Overrides> & Custom>> : iAPI<Modify<T, Overrides> & Custom>;
+export interface iCacheAPI<ResponseDataType = any> {
+    requestArgumentsSerialized: string;
+    request: AxiosPromise<ResponseDataType>;
+    response?: AxiosResponse;
+    final?: boolean;
+}
+export interface iChangeC6Data {
+    rowCount: number;
+}
+export interface iDeleteC6RestResponse<RestData = any, RequestData = any> extends iChangeC6Data, iC6RestResponse<RestData> {
+    deleted: boolean | number | string | RequestData;
+}
+export interface iPostC6RestResponse<RestData = any> extends iC6RestResponse<RestData> {
+    created: boolean | number | string;
+}
+export interface iPutC6RestResponse<RestData = any, RequestData = any> extends iChangeC6Data, iC6RestResponse<RestData> {
+    updated: boolean | number | string | RequestData;
+}
+export interface iC6RestResponse<RestData> {
+    rest: RestData;
+    session?: any;
+    sql?: any;
+}
+export type iGetC6RestResponse<ResponseDataType, ResponseDataOverrides = {}> = iC6RestResponse<Modify<ResponseDataType, ResponseDataOverrides> | Modify<ResponseDataType, ResponseDataOverrides>[]>;
+export type apiReturn<Response> = null | undefined | AxiosPromise<Response> | (Response extends iPutC6RestResponse | iDeleteC6RestResponse | iPostC6RestResponse ? null : () => apiReturn<Response>);
+export type DetermineResponseDataType<Method extends iRestMethods, RestTableInterface extends {
+    [key: string]: any;
+}> = Method extends 'POST' ? iPostC6RestResponse<RestTableInterface> : Method extends 'GET' ? iGetC6RestResponse<RestTableInterface> : Method extends 'PUT' ? iPutC6RestResponse<RestTableInterface> : Method extends 'DELETE' ? iDeleteC6RestResponse<RestTableInterface> : never;
+export interface iRest<RestShortTableName extends string = any, RestTableInterface extends {
+    [key: string]: any;
+} = any, PrimaryKey extends keyof RestTableInterface & string = any> {
+    C6: iC6Object;
+    axios?: AxiosInstance;
+    restURL?: string;
+    mysqlPool?: Pool;
+    withCredentials?: boolean;
+    restModel: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey>;
+    reactBootstrap?: CarbonReact<any, any>;
+    requestMethod: iRestMethods;
+    clearCache?: () => void;
+    skipPrimaryCheck?: boolean;
+}
 export interface iConstraint {
     TABLE: string;
     COLUMN: string;
@@ -99,116 +154,66 @@ export interface iC6RestfulModel<RestShortTableNames extends string, RestTableIn
         [columnName: string]: iConstraint[];
     };
 }
-export interface iRestApiFunctions<RestData = any> {
-    Delete: (request?: (iAPI<any> & any)) => apiReturn<iDeleteC6RestResponse<RestData>>;
-    Post: (request?: (iAPI<any> & any)) => apiReturn<iPostC6RestResponse<RestData>>;
-    Get: (request?: (iAPI<any> & any)) => apiReturn<iGetC6RestResponse<RestData>>;
-    Put: (request?: (iAPI<any> & any)) => apiReturn<iPutC6RestResponse<RestData>>;
-}
-export interface iDynamicApiImport<RestData = any> {
-    default: iRestApiFunctions<RestData>;
-    postState?: (response: AxiosResponse<iPostC6RestResponse<RestData>>, request: iAPI<any>, id: string | number | boolean) => void;
-    deleteState?: (response: AxiosResponse<iDeleteC6RestResponse<RestData>>, request: iAPI<any>) => void;
-    putState?: (response: AxiosResponse<iPutC6RestResponse<RestData>>, request: iAPI<any>) => void;
-}
-export interface tC6Tables<RestShortTableName extends string = any, RestTableInterface extends {
+export type iRestReactiveLifecycle<Method extends iRestMethods, RestShortTableName extends string, RestTableInterface extends {
     [key: string]: any;
-} = any, PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>> {
-    [key: string]: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey> & {
-        [key: string]: any;
+}, PrimaryKey extends keyof RestTableInterface & string, CustomAndRequiredFields extends {
+    [key: string]: any;
+}, RequestTableOverrides extends {
+    [key: string]: any;
+}> = {
+    beforeProcessing?: {
+        [key: string]: (args: {
+            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
+            request: RequestQueryBody<Method, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
+        }) => void | Promise<void>;
     };
-}
-export interface tC6RestApi {
-    [key: string]: {
-        REST: iRestApiFunctions;
-        PUT: Function;
-        POST: Function;
-        DELETE: Function;
+    beforeExecution?: {
+        [key: string]: (args: {
+            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
+            request: RequestQueryBody<Method, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
+        }) => void | Promise<void>;
+    };
+    afterExecution?: {
+        [key: string]: (args: {
+            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
+            request: RequestQueryBody<Method, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
+            response: AxiosResponse<DetermineResponseDataType<Method, RestTableInterface>>;
+        }) => void | Promise<void>;
+    };
+    afterCommit?: {
+        [key: string]: (args: {
+            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
+            request: RequestQueryBody<Method, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
+            response: AxiosResponse<DetermineResponseDataType<Method, RestTableInterface>>;
+        }) => void | Promise<void>;
     };
-}
-export type iAPI<RestTableInterfaces extends {
-    [key: string]: any;
-}> = RestTableInterfaces & {
-    dataInsertMultipleRows?: RestTableInterfaces[];
-    cacheResults?: boolean;
-    fetchDependencies?: number | eFetchDependencies | Awaited<apiReturn<iGetC6RestResponse<any>>>[];
-    debug?: boolean;
-    success?: string | ((r: AxiosResponse) => (string | void));
-    error?: string | ((r: AxiosResponse) => (string | void));
-};
-export interface iCacheAPI<ResponseDataType = any> {
-    requestArgumentsSerialized: string;
-    request: AxiosPromise<ResponseDataType>;
-    response?: AxiosResponse;
-    final?: boolean;
-}
-/**
- * the first argument ....
- *
- * Our api returns a zero argument function iff the method is get and the previous request reached the predefined limit.
- * This function can be aliased as GetNextPageOfResults(). If the end is reached undefined will be returned.
- *
- *
- * For POST, PUT, and DELETE requests one can expect the primary key of the new or modified index, or a boolean success
- * indication if no primary key exists.
- **/
-export declare const POST = "POST";
-export declare const PUT = "PUT";
-export declare const GET = "GET";
-export declare const DELETE = "DELETE";
-export type iRestMethods = 'GET' | 'POST' | 'PUT' | 'DELETE';
-export type SubSelect<T = any> = {
-    subSelect: true;
-    table: string;
-    args: RequestGetPutDeleteBody<T>;
-    alias: string;
-};
-export type SelectField<T = any> = keyof T | [keyof T, 'AS', string] | [SQLFunction, keyof T] | [SQLFunction, keyof T, string] | SubSelect<T>;
-export type WhereClause<T = any> = Partial<T> | LogicalGroup<T> | ComparisonClause<T>;
-export type LogicalGroup<T = any> = {
-    [logicalGroup: string]: Array<WhereClause<T>>;
-};
-export type ComparisonClause<T = any> = [keyof T, SQLComparisonOperator, any];
-export type JoinTableCondition<T = any> = Partial<T> | WhereClause<T>[] | ComparisonClause<T>[];
-export type JoinClause<T = any> = {
-    [table: string]: JoinTableCondition<T>;
-};
-export type Join<T = any> = {
-    [K in JoinType]?: JoinClause<T>;
-};
-export type Pagination<T = any> = {
-    PAGE?: number;
-    LIMIT?: number | null;
-    ORDER?: Partial<Record<keyof T, OrderDirection>>;
 };
-export type RequestGetPutDeleteBody<T = any> = {
-    SELECT?: SelectField<T>[];
-    UPDATE?: Partial<T>;
-    DELETE?: boolean;
-    WHERE?: WhereClause<T>;
-    JOIN?: Join<T>;
-    PAGINATION?: Pagination<T>;
+export type iRestHooks<RestShortTableName extends string, RestTableInterface extends {
+    [key: string]: any;
+}, PrimaryKey extends keyof RestTableInterface & string, CustomAndRequiredFields extends {
+    [key: string]: any;
+} = any, RequestTableOverrides extends {
+    [key: string]: any;
+} = {
+    [key in keyof RestTableInterface]: any;
+}> = {
+    [Method in iRestMethods]: iRestReactiveLifecycle<Method, RestShortTableName, RestTableInterface, PrimaryKey, CustomAndRequiredFields, RequestTableOverrides>;
 };
-export type RequestQueryBody<RestTableInterfaces extends {
+export interface iDynamicApiImport<RestData extends {
     [key: string]: any;
-}> = iAPI<RestTableInterfaces> | RequestGetPutDeleteBody;
-export declare function isPromise(x: any): boolean;
-interface iC6RestResponse<RestData> {
-    rest: RestData;
-    session?: any;
-    sql?: any;
-}
-interface iChangeC6Data {
-    rowCount: number;
-}
-export interface iDeleteC6RestResponse<RestData = any, RequestData = any> extends iChangeC6Data, iC6RestResponse<RestData> {
-    deleted: boolean | number | string | RequestData;
-}
-export interface iPostC6RestResponse<RestData = any> extends iC6RestResponse<RestData> {
-    created: boolean | number | string;
+} = any> {
+    default: iRestApiFunctions<RestData>;
+    postState?: (response: AxiosResponse<iPostC6RestResponse<RestData>>, request: iAPI<any>, id: string | number | boolean) => void;
+    deleteState?: (response: AxiosResponse<iDeleteC6RestResponse<RestData>>, request: iAPI<any>) => void;
+    putState?: (response: AxiosResponse<iPutC6RestResponse<RestData>>, request: iAPI<any>) => void;
 }
-export interface iPutC6RestResponse<RestData = any, RequestData = any> extends iChangeC6Data, iC6RestResponse<RestData> {
-    updated: boolean | number | string | RequestData;
+export interface iRestApiFunctions<RestData extends {
+    [key: string]: any;
+} = any> {
+    Delete: (request?: RequestQueryBody<'DELETE', RestData>) => apiReturn<iDeleteC6RestResponse<RestData>>;
+    Post: (request?: RequestQueryBody<'POST', RestData>) => apiReturn<iPostC6RestResponse<RestData>>;
+    Get: (request?: RequestQueryBody<'GET', RestData>) => apiReturn<iGetC6RestResponse<RestData>>;
+    Put: (request?: RequestQueryBody<'PUT', RestData>) => apiReturn<iPutC6RestResponse<RestData>>;
 }
 export interface iC6Object<RestShortTableName extends string = any, RestTableInterface extends {
     [key: string]: any;
@@ -223,23 +228,18 @@ export interface iC6Object<RestShortTableName extends string = any, RestTableInt
     IMPORT: (tableName: string) => Promise<iDynamicApiImport>;
     [key: string]: any;
 }
-export type iGetC6RestResponse<ResponseDataType, ResponseDataOverrides = {}> = iC6RestResponse<Modify<ResponseDataType, ResponseDataOverrides> | Modify<ResponseDataType, ResponseDataOverrides>[]>;
-export type apiReturn<Response> = null | undefined | AxiosPromise<Response> | (Response extends iPutC6RestResponse | iDeleteC6RestResponse | iPostC6RestResponse ? null : (() => apiReturn<Response>));
-export type DetermineResponseDataType<RequestMethod extends iRestMethods, RestTableInterface extends {
-    [key: string]: any;
-}> = RequestMethod extends "POST" ? iPostC6RestResponse<RestTableInterface> : RequestMethod extends "GET" ? iGetC6RestResponse<RestTableInterface> : RequestMethod extends "PUT" ? iPutC6RestResponse<RestTableInterface> : RequestMethod extends "DELETE" ? iDeleteC6RestResponse<RestTableInterface> : any;
-export interface iRest<RestShortTableName extends string = any, RestTableInterface extends {
+export interface tC6Tables<RestShortTableName extends string = any, RestTableInterface extends {
     [key: string]: any;
-} = any, PrimaryKey extends keyof RestTableInterface & string = any> {
-    C6: iC6Object;
-    axios?: AxiosInstance;
-    restURL?: string;
-    mysqlPool?: Pool;
-    withCredentials?: boolean;
-    restModel: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey>;
-    reactBootstrap?: CarbonReact<any, any>;
-    requestMethod: iRestMethods;
-    clearCache?: () => void;
-    skipPrimaryCheck?: boolean;
+} = any, PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>> {
+    [key: string]: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey> & {
+        [key: string]: any;
+    };
+}
+export interface tC6RestApi {
+    [key: string]: {
+        REST: iRestApiFunctions;
+        PUT: Function;
+        POST: Function;
+        DELETE: Function;
+    };
 }
-export {};