Updates

dist/package-shared/functions/api/query/get.d.ts

@@ -0,0 +1,25 @@
+import { DbContextsArray } from "../../backend/db/runQuery";
+import { ApiGetQueryObject } from "../../../types";
+type Param<T extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}> = {
+    query: string | ApiGetQueryObject<T>;
+    queryValues?: (string | number)[];
+    dbFullName: string;
+    tableName?: string;
+    dbSchema?: import("../../../types").DSQL_DatabaseSchemaType;
+    debug?: boolean;
+    dbContext?: (typeof DbContextsArray)[number];
+    forceLocal?: boolean;
+};
+/**
+ * # Get Function FOr API
+ */
+export default function apiGet<T extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}>({ query, dbFullName, queryValues, tableName, dbSchema, debug, dbContext, forceLocal, }: Param<T>): Promise<import("../../../types").GetReturn>;
+export {};

dist/package-shared/functions/api/query/post.d.ts

@@ -0,0 +1,16 @@
+import { DbContextsArray } from "../../backend/db/runQuery";
+import { DSQL_DatabaseSchemaType, PostReturn } from "../../../types";
+type Param = {
+    query: any;
+    queryValues?: (string | number)[];
+    dbFullName: string;
+    tableName?: string;
+    dbSchema?: DSQL_DatabaseSchemaType;
+    dbContext?: (typeof DbContextsArray)[number];
+    forceLocal?: boolean;
+};
+/**
+ * # Post Function For API
+ */
+export default function apiPost({ query, dbFullName, queryValues, tableName, dbSchema, dbContext, forceLocal, }: Param): Promise<PostReturn>;
+export {};

dist/package-shared/functions/api/social-login/facebookLogin.d.ts

@@ -0,0 +1,8 @@
+import { UserType } from "../../../types";
+/**
+ * # Facebook Login
+ */
+export default function facebookLogin({ usertype, body, }: {
+    body: any;
+    usertype: UserType;
+}): Promise<any>;

dist/package-shared/functions/api/social-login/githubLogin.d.ts

@@ -0,0 +1,43 @@
+export interface GithubUserPayload {
+    login: string;
+    id: number;
+    node_id: string;
+    avatar_url: string;
+    gravatar_id: string;
+    url: string;
+    html_url: string;
+    followers_url: string;
+    following_url: string;
+    gists_url: string;
+    starred_url: string;
+    subscriptions_url: string;
+    organizations_url: string;
+    repos_url: string;
+    received_events_url: string;
+    type: string;
+    site_admin: boolean;
+    name: string;
+    company: string;
+    blog: string;
+    location: string;
+    email: string;
+    hireable: string;
+    bio: string;
+    twitter_username: string;
+    public_repos: number;
+    public_gists: number;
+    followers: number;
+    following: number;
+    created_at: string;
+    updated_at: string;
+}
+type Param = {
+    code: string;
+    clientId: string;
+    clientSecret: string;
+};
+/**
+ * # Login/signup a github user
+ */
+export default function githubLogin({ code, clientId, clientSecret, }: Param): Promise<GithubUserPayload | null | undefined>;
+export {};

dist/package-shared/functions/api/social-login/googleLogin.d.ts

@@ -0,0 +1,22 @@
+type Param = {
+    usertype: string;
+    foundUser: any;
+    isSocialValidated: boolean;
+    isUserValid: boolean;
+    reqBody: any;
+    serverRes: any;
+    loginFailureReason: any;
+};
+/**
+ * # Google Login
+ */
+export default function googleLogin({ usertype, foundUser, isSocialValidated, isUserValid, reqBody, serverRes, loginFailureReason, }: Param): Promise<{
+    isGoogleAuthValid: boolean;
+    newFoundUser: null;
+    loginFailureReason: any;
+} | {
+    isGoogleAuthValid: boolean;
+    newFoundUser: any;
+    loginFailureReason?: undefined;
+} | undefined>;
+export {};

dist/package-shared/functions/api/social-login/handleSocialDb.d.ts

@@ -0,0 +1,5 @@
+import { APILoginFunctionReturn, HandleSocialDbFunctionParams } from "../../../types";
+/**
+ * # Handle Social DB
+ */
+export default function handleSocialDb({ database, social_id, email, social_platform, payload, invitation, supEmail, additionalFields, debug, }: HandleSocialDbFunctionParams): Promise<APILoginFunctionReturn>;

dist/package-shared/functions/api/social-login/loginSocialUser.d.ts

@@ -0,0 +1,22 @@
+import { APILoginFunctionReturn } from "../../../types";
+type Param = {
+    user: {
+        first_name: string;
+        last_name: string;
+        email: string;
+        social_id: string | number;
+    };
+    social_platform: string;
+    invitation?: any;
+    database?: string;
+    additionalFields?: string[];
+    debug?: boolean;
+};
+/**
+ * Function to login social user
+ * ==============================================================================
+ * @description This function logs in the user after 'handleSocialDb' function finishes
+ * the user creation or confirmation process
+ */
+export default function loginSocialUser({ user, social_platform, invitation, database, additionalFields, debug, }: Param): Promise<APILoginFunctionReturn>;
+export {};

dist/package-shared/functions/api/users/api-create-user.d.ts

@@ -0,0 +1,25 @@
+import { APICreateUserFunctionParams } from "../../../types";
+/**
+ * # API Create User
+ */
+export default function apiCreateUser({ encryptionKey, payload, database, userId, }: APICreateUserFunctionParams): Promise<{
+    success: boolean;
+    msg: string;
+    payload?: undefined;
+    sqlResult?: undefined;
+} | {
+    success: boolean;
+    msg: string | undefined;
+    payload: null;
+    sqlResult?: undefined;
+} | {
+    success: boolean;
+    payload: any;
+    msg?: undefined;
+    sqlResult?: undefined;
+} | {
+    success: boolean;
+    msg: string;
+    sqlResult: any;
+    payload: null;
+}>;

dist/package-shared/functions/api/users/api-delete-user.d.ts

@@ -0,0 +1,14 @@
+type Param = {
+    dbFullName: string;
+    deletedUserId: string | number;
+};
+type Return = {
+    success: boolean;
+    result?: any;
+    msg?: string;
+};
+/**
+ * # Update API User Function
+ */
+export default function apiDeleteUser({ dbFullName, deletedUserId, }: Param): Promise<Return>;
+export {};

dist/package-shared/functions/api/users/api-get-user.d.ts

@@ -0,0 +1,5 @@
+import { APIGetUserFunctionParams, GetUserFunctionReturn } from "../../../types";
+/**
+ * # API Get User
+ */
+export default function apiGetUser({ fields, dbFullName, userId, }: APIGetUserFunctionParams): Promise<GetUserFunctionReturn>;

dist/package-shared/functions/api/users/api-login.d.ts

@@ -0,0 +1,5 @@
+import { APILoginFunctionParams, APILoginFunctionReturn } from "../../../types";
+/**
+ * # API Login
+ */
+export default function apiLoginUser({ encryptionKey, email, username, password, database, additionalFields, email_login, email_login_code, email_login_field, skipPassword, social, dbUserId, debug, }: APILoginFunctionParams): Promise<APILoginFunctionReturn>;

dist/package-shared/functions/api/users/api-reauth-user.d.ts

@@ -0,0 +1,13 @@
+import { APILoginFunctionReturn } from "../../../types";
+type Param = {
+    existingUser: {
+        [s: string]: any;
+    };
+    database?: string;
+    additionalFields?: string[];
+};
+/**
+ * # Re-authenticate API user
+ */
+export default function apiReauthUser({ existingUser, database, additionalFields, }: Param): Promise<APILoginFunctionReturn>;
+export {};

dist/package-shared/functions/api/users/api-send-email-code.d.ts

@@ -0,0 +1,22 @@
+import http from "http";
+import { SendOneTimeCodeEmailResponse } from "../../../types";
+type Param = {
+    email: string;
+    database: string;
+    email_login_field?: string;
+    mail_domain?: string;
+    mail_port?: number;
+    sender?: string;
+    mail_username?: string;
+    mail_password?: string;
+    html: string;
+    response?: http.ServerResponse & {
+        [s: string]: any;
+    };
+    extraCookies?: import("../../../../package-shared/types").CookieObject[];
+};
+/**
+ * # Send Email Login Code
+ */
+export default function apiSendEmailCode({ email, database, email_login_field, mail_domain, mail_port, sender, mail_username, mail_password, html, response, extraCookies, }: Param): Promise<SendOneTimeCodeEmailResponse>;
+export {};

dist/package-shared/functions/api/users/api-update-user.d.ts

@@ -0,0 +1,18 @@
+type Param = {
+    payload: {
+        [s: string]: any;
+    };
+    dbFullName: string;
+    updatedUserId: string | number;
+    dbSchema?: import("../../../types").DSQL_DatabaseSchemaType;
+};
+type Return = {
+    success: boolean;
+    payload?: any;
+    msg?: string;
+};
+/**
+ * # Update API User Function
+ */
+export default function apiUpdateUser({ payload, dbFullName, updatedUserId, dbSchema, }: Param): Promise<Return>;
+export {};

dist/package-shared/functions/api/users/reset-password/(utils)/encrypt-url.d.ts

@@ -0,0 +1,11 @@
+type Param = {
+    email: string;
+    encryptionKey?: string;
+    encryptionSalt?: string;
+};
+export type EncryptResetPasswordObject = {
+    email: string;
+    createdAt: number;
+};
+export default function encryptReserPasswordUrl({ email, encryptionKey, encryptionSalt, }: Param): void;
+export {};

dist/package-shared/functions/api/users/reset-password/api-send-reset-password-link.d.ts

@@ -0,0 +1,22 @@
+type Return = {
+    success: boolean;
+    msg?: string;
+    error?: string;
+};
+type Param = {
+    key?: string;
+    database: string;
+    email: string;
+    encryptionKey?: string;
+    encryptionSalt?: string;
+    debug?: boolean;
+    apiUserID?: string | number;
+    dbUserId?: string | number;
+};
+/**
+ * # API Login
+ */
+export default function apiSendResetPasswordLink({ database, email, dbUserId, debug, }: Param): Promise<Return>;
+export type SendResetPasswordParam = Param;
+export type SendResetPasswordReturn = Return;
+export {};

dist/package-shared/functions/api/users/social/api-github-login.d.ts

@@ -0,0 +1,17 @@
+import { APILoginFunctionReturn } from "../../../../types";
+type Param = {
+    code?: string;
+    clientId?: string;
+    clientSecret?: string;
+    database?: string;
+    additionalFields?: string[];
+    additionalData?: {
+        [s: string]: string | number;
+    };
+    email?: string;
+};
+/**
+ * # API Login with Github
+ */
+export default function apiGithubLogin({ code, clientId, clientSecret, database, additionalFields, email, additionalData, }: Param): Promise<APILoginFunctionReturn>;
+export {};

dist/package-shared/functions/api/users/social/api-google-login.d.ts

@@ -0,0 +1,5 @@
+import { APIGoogleLoginFunctionParams, APILoginFunctionReturn } from "../../../../types";
+/**
+ * # API google login
+ */
+export default function apiGoogleLogin({ token, database, additionalFields, additionalData, debug, }: APIGoogleLoginFunctionParams): Promise<APILoginFunctionReturn>;

dist/package-shared/functions/backend/addAdminUserOnLogin.d.ts

@@ -0,0 +1,20 @@
+import { DATASQUIREL_LoggedInUser } from "../../types";
+type Param = {
+    query: {
+        invite: number;
+        database_access: string;
+        priviledge: string;
+        email: string;
+    };
+    user: DATASQUIREL_LoggedInUser;
+};
+/**
+ * Add Admin User on Login
+ * ==============================================================================
+ *
+ * @description this function handles admin users that have been invited by another
+ * admin user. This fires when the invited user has been logged in or a new account
+ * has been created for the invited user
+ */
+export default function addAdminUserOnLogin({ query, user, }: Param): Promise<any>;
+export {};

dist/package-shared/functions/backend/addMariadbUser.d.ts

@@ -0,0 +1,8 @@
+type Param = {
+    userId: number | string;
+};
+/**
+ * # Add Mariadb User
+ */
+export default function addMariadbUser({ userId }: Param): Promise<any>;
+export {};

dist/package-shared/functions/backend/addUsersTableToDb.d.ts

@@ -0,0 +1,12 @@
+type Param = {
+    userId: number;
+    database: string;
+    payload?: {
+        [s: string]: any;
+    };
+};
+/**
+ * # Add User Table to Database
+ */
+export default function addUsersTableToDb({ userId, database, payload, }: Param): Promise<any>;
+export {};

dist/package-shared/functions/backend/api-cred.d.ts

@@ -0,0 +1,6 @@
+import { CheckApiCredentialsFn } from "../../types";
+/**
+ * # Grap API Credentials
+ */
+declare const grabApiCred: CheckApiCredentialsFn;
+export default grabApiCred;

dist/package-shared/functions/backend/auth/write-auth-files.d.ts

@@ -0,0 +1,29 @@
+export declare const grabAuthDirs: () => {
+    root: string;
+    auth: string;
+};
+export declare const initAuthFiles: () => boolean;
+/**
+ * # Write Auth Files
+ */
+export declare const writeAuthFile: (name: string, data: string, cleanup?: {
+    userId: string | number;
+}) => boolean;
+/**
+ * # Clean up User Auth Files
+ */
+export declare const cleanupUserAuthFiles: (userId: string | number) => boolean;
+/**
+ * # Get Auth Files
+ */
+export declare const getAuthFile: (name: string) => string | null;
+/**
+ * # Delete Auth Files
+ * @param {string} name
+ */
+export declare const deleteAuthFile: (name: string) => void | null;
+/**
+ * # Delete Auth Files
+ * @param {string} name
+ */
+export declare const checkAuthFile: (name: string) => boolean;

dist/package-shared/functions/backend/cookies/get-auth-cookie-names.d.ts

@@ -0,0 +1,14 @@
+type Param = {
+    database?: string;
+    userId?: string | number;
+};
+type Return = {
+    keyCookieName: string;
+    csrfCookieName: string;
+    oneTimeCodeName: string;
+};
+/**
+ * # Grab Auth Cookie Names
+ */
+export default function getAuthCookieNames(params?: Param): Return;
+export {};

dist/package-shared/functions/backend/db/addDbEntry.d.ts

@@ -0,0 +1,20 @@
+import { DbContextsArray } from "./runQuery";
+type Param = {
+    dbContext?: (typeof DbContextsArray)[number];
+    paradigm?: "Read Only" | "Full Access";
+    dbFullName?: string;
+    tableName: string;
+    data: any;
+    tableSchema?: import("../../../types").DSQL_TableSchemaType;
+    duplicateColumnName?: string;
+    duplicateColumnValue?: string;
+    update?: boolean;
+    encryptionKey?: string;
+    encryptionSalt?: string;
+    forceLocal?: boolean;
+};
+/**
+ * Add a db Entry Function
+ */
+export default function addDbEntry({ dbContext, paradigm, dbFullName, tableName, data, tableSchema, duplicateColumnName, duplicateColumnValue, update, encryptionKey, encryptionSalt, forceLocal, }: Param): Promise<any>;
+export {};

dist/package-shared/functions/backend/db/deleteDbEntry.d.ts

@@ -0,0 +1,16 @@
+import { DbContextsArray } from "./runQuery";
+type Param = {
+    dbContext?: (typeof DbContextsArray)[number];
+    dbFullName: string;
+    tableName: string;
+    tableSchema?: import("../../../types").DSQL_TableSchemaType;
+    identifierColumnName: string;
+    identifierValue: string | number;
+    forceLocal?: boolean;
+};
+/**
+ * # Delete DB Entry Function
+ * @description
+ */
+export default function deleteDbEntry({ dbContext, dbFullName, tableName, identifierColumnName, identifierValue, forceLocal, }: Param): Promise<object | null>;
+export {};

dist/package-shared/functions/backend/db/pathTraversalCheck.d.ts

@@ -0,0 +1,5 @@
+/**
+ * # Path Traversal Check
+ * @returns {string}
+ */
+export default function pathTraversalCheck(text: string | number): string;

dist/package-shared/functions/backend/db/runQuery.d.ts

@@ -0,0 +1,21 @@
+export declare const DbContextsArray: readonly ["Master", "Dsql User"];
+type Param = {
+    dbContext?: (typeof DbContextsArray)[number];
+    dbFullName: string;
+    query: string | any;
+    readOnly?: boolean;
+    debug?: boolean;
+    dbSchema?: import("../../../types").DSQL_DatabaseSchemaType;
+    queryValuesArray?: (string | number)[];
+    tableName?: string;
+    forceLocal?: boolean;
+};
+type Return = {
+    result: any;
+    error?: string;
+};
+/**
+ * # Run DSQL users queries
+ */
+export default function runQuery({ dbFullName, query, readOnly, dbSchema, queryValuesArray, tableName, debug, dbContext, forceLocal, }: Param): Promise<Return>;
+export {};

dist/package-shared/functions/backend/db/sanitizeSql.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Sanitize SQL function
+ * ==============================================================================
+ * @description this function takes in a text(or number) and returns a sanitized
+ * text, usually without spaces
+ */
+declare function sanitizeSql(text: any, spaces?: boolean, regex?: RegExp | null): any;
+export default sanitizeSql;

dist/package-shared/functions/backend/db/updateDbEntry.d.ts

@@ -0,0 +1,19 @@
+import { DbContextsArray } from "./runQuery";
+type Param = {
+    dbContext?: (typeof DbContextsArray)[number];
+    dbFullName?: string;
+    tableName: string;
+    encryptionKey?: string;
+    encryptionSalt?: string;
+    data: any;
+    tableSchema?: import("../../../types").DSQL_TableSchemaType;
+    identifierColumnName: string;
+    identifierValue: string | number;
+    forceLocal?: boolean;
+};
+/**
+ * # Update DB Function
+ * @description
+ */
+export default function updateDbEntry({ dbContext, dbFullName, tableName, data, tableSchema, identifierColumnName, identifierValue, encryptionKey, encryptionSalt, forceLocal, }: Param): Promise<object | null>;
+export {};

dist/package-shared/functions/backend/dbHandler.d.ts

@@ -0,0 +1,4 @@
+/**
+ * # Main DB Handler Function
+ */
+export default function dbHandler(...args: any[]): Promise<any>;

dist/package-shared/functions/backend/defaultFieldsRegexp.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Regular expression to match default fields
+ *
+ * @description Regular expression to match default fields
+ */
+declare const defaultFieldsRegexp: RegExp;
+export default defaultFieldsRegexp;

dist/package-shared/functions/backend/fullAccessDbHandler.d.ts

@@ -0,0 +1,11 @@
+type Param = {
+    queryString: string;
+    tableSchema?: import("../../types").DSQL_TableSchemaType | null;
+    queryValuesArray?: string[];
+    forceLocal?: boolean;
+};
+/**
+ * # Full Access Db Handler
+ */
+export default function fullAccessDbHandler({ queryString, tableSchema, queryValuesArray, forceLocal, }: Param): Promise<any>;
+export {};

dist/package-shared/functions/backend/grabNewUsersTableSchema.d.ts

@@ -0,0 +1,9 @@
+import { DSQL_TableSchemaType } from "../../types";
+/**
+ * # Add User Table to Database
+ */
+export default function grabNewUsersTableSchema(params: {
+    payload?: {
+        [s: string]: any;
+    };
+}): DSQL_TableSchemaType | null;

dist/package-shared/functions/backend/grabSchemaFieldsFromData.d.ts

@@ -0,0 +1,16 @@
+import { DSQL_FieldSchemaType } from "../../types";
+type Param = {
+    data?: {
+        [s: string]: any;
+    };
+    fields?: string[];
+    excludeData?: {
+        [s: string]: any;
+    };
+    excludeFields?: DSQL_FieldSchemaType[];
+};
+/**
+ * # Add User Table to Database
+ */
+export default function grabSchemaFieldsFromData({ data, fields, excludeData, excludeFields, }: Param): DSQL_FieldSchemaType[];
+export {};

dist/package-shared/functions/backend/grabUserSchemaData.d.ts

@@ -0,0 +1,6 @@
+/**
+ * # Grab User Schema Data
+ */
+export default function grabUserSchemaData({ userId, }: {
+    userId: string | number;
+}): import("../../types").DSQL_DatabaseSchemaType[] | null;

dist/package-shared/functions/backend/handleNodemailer.d.ts

@@ -0,0 +1,11 @@
+import Mail from "nodemailer/lib/mailer";
+import SMTPTransport from "nodemailer/lib/smtp-transport";
+export type HandleNodemailerParam = Mail.Options & {
+    senderName?: string;
+    alias?: string | null;
+    options?: SMTPTransport.Options;
+};
+/**
+ * # Handle mails With Nodemailer
+ */
+export default function handleNodemailer(params: HandleNodemailerParam): Promise<SMTPTransport.SentMessageInfo | undefined>;

dist/package-shared/functions/backend/html/sanitizeHtmlOptions.d.ts

@@ -0,0 +1,9 @@
+declare const sanitizeHtmlOptions: {
+    allowedTags: string[];
+    allowedAttributes: {
+        a: string[];
+        img: string[];
+        "*": string[];
+    };
+};
+export default sanitizeHtmlOptions;

dist/package-shared/functions/backend/httpRequest.d.ts

@@ -0,0 +1,13 @@
+import { HttpFunctionResponse, HttpRequestParams } from "../../types";
+/**
+ * # Generate a http Request
+ */
+export default function httpRequest<ReqObj extends {
+    [k: string]: any;
+} = {
+    [k: string]: any;
+}, ResObj extends {
+    [k: string]: any;
+} = {
+    [k: string]: any;
+}>(params: HttpRequestParams<ReqObj>): Promise<HttpFunctionResponse<ResObj>>;

dist/package-shared/functions/backend/httpsRequest.d.ts

@@ -0,0 +1,15 @@
+type Param = {
+    scheme?: string;
+    url?: string;
+    method?: string;
+    hostname?: string;
+    path?: string;
+    port?: number | string;
+    headers?: object;
+    body?: object;
+};
+/**
+ * # Make Https Request
+ */
+export default function httpsRequest({ url, method, hostname, path, headers, body, port, scheme, }: Param): Promise<unknown>;
+export {};

dist/package-shared/functions/backend/noDatabaseDbHandler.d.ts

@@ -0,0 +1,4 @@
+/**
+ * # No Database DB Handler
+ */
+export default function noDatabaseDbHandler(queryString: string): Promise<any>;

dist/package-shared/functions/backend/parseDbResults.d.ts

@@ -0,0 +1,13 @@
+type Param = {
+    unparsedResults: any[];
+    tableSchema?: import("../../types").DSQL_TableSchemaType;
+};
+/**
+ * Parse Database results
+ * ==============================================================================
+ * @description this function takes a database results array gotten from a DB handler
+ * function, decrypts encrypted fields, and returns an updated array with no encrypted
+ * fields
+ */
+export default function parseDbResults({ unparsedResults, tableSchema, }: Param): Promise<any[] | null>;
+export {};

dist/package-shared/functions/backend/queues/add-queue.d.ts

@@ -0,0 +1,10 @@
+import { DSQL_DATASQUIREL_PROCESS_QUEUE } from "../../../types/dsql";
+type Param = {
+    queue: DSQL_DATASQUIREL_PROCESS_QUEUE;
+    userId: string | number;
+    dummy?: boolean;
+};
+export default function addQueue({ queue, userId, dummy }: Param): Promise<(import("../../../types").PostReturn & {
+    queryObject?: ReturnType<Awaited<typeof import("../../dsql/sql/sql-generator").default>>;
+}) | null | undefined>;
+export {};

dist/package-shared/functions/backend/queues/delete-queue.d.ts

@@ -0,0 +1,6 @@
+type Param = {
+    queueId: string | number;
+    userId: string | number;
+};
+export default function deleteQueue({ queueId, userId }: Param): Promise<boolean>;
+export {};

dist/package-shared/functions/backend/queues/get-queue.d.ts

@@ -0,0 +1,10 @@
+import { DSQL_DATASQUIREL_PROCESS_QUEUE } from "../../../types/dsql";
+import { DsqlCrudQueryObject } from "../../../types";
+type Param = {
+    queueId?: string | number;
+    userId?: string | number;
+    query?: DsqlCrudQueryObject<DSQL_DATASQUIREL_PROCESS_QUEUE>;
+    single?: boolean;
+};
+export default function getQueue({ queueId, userId, query, single, }: Param): Promise<DSQL_DATASQUIREL_PROCESS_QUEUE | DSQL_DATASQUIREL_PROCESS_QUEUE[] | undefined>;
+export {};

dist/package-shared/functions/backend/queues/update-queue.d.ts

@@ -0,0 +1,7 @@
+import { DSQL_DATASQUIREL_PROCESS_QUEUE } from "../../../types/dsql";
+type Param = {
+    queueId: string | number;
+    queue: DSQL_DATASQUIREL_PROCESS_QUEUE;
+};
+export default function updateQueue({ queueId, queue }: Param): Promise<boolean>;
+export {};

dist/package-shared/functions/backend/serverError.d.ts

@@ -0,0 +1,18 @@
+import { IncomingMessage } from "http";
+type Param = {
+    user?: {
+        id?: number | string;
+        first_name?: string;
+        last_name?: string;
+        email?: string;
+    } & any;
+    message: string;
+    component?: string;
+    noMail?: boolean;
+    req?: import("next").NextApiRequest & IncomingMessage;
+};
+/**
+ * # Server Error
+ */
+export default function serverError({ user, message, component, noMail, req, }: Param): Promise<void>;
+export {};

dist/package-shared/functions/backend/setUserSchemaData.d.ts

@@ -0,0 +1,10 @@
+import { DSQL_DatabaseSchemaType } from "../../types";
+type Param = {
+    userId: string | number;
+    schemaData: DSQL_DatabaseSchemaType[];
+};
+/**
+ * # Set User Schema Data
+ */
+export default function setUserSchemaData({ userId, schemaData, }: Param): boolean;
+export {};

dist/package-shared/functions/backend/suSocketAuth.d.ts

@@ -0,0 +1,8 @@
+import { IncomingMessage } from "http";
+export default function (req: IncomingMessage): Promise<{
+    email: string;
+    password: string;
+    authKey: string;
+    logged_in_status: boolean;
+    date: number;
+} | null>;

dist/package-shared/functions/backend/updateUsersTableSchema.d.ts

@@ -0,0 +1,13 @@
+type Param = {
+    userId: number | string;
+    database: string;
+    newFields?: string[];
+    newPayload?: {
+        [s: string]: any;
+    };
+};
+/**
+ * # Add User Table to Database
+ */
+export default function updateUsersTableSchema({ userId, database, newFields, newPayload, }: Param): Promise<any>;
+export {};

dist/package-shared/functions/backend/varDatabaseDbHandler.d.ts

@@ -0,0 +1,12 @@
+type Param = {
+    queryString: string;
+    queryValuesArray?: any[];
+    database?: string;
+    tableSchema?: import("../../types").DSQL_TableSchemaType;
+    debug?: boolean;
+};
+/**
+ * # DB handler for specific database
+ */
+export default function varDatabaseDbHandler({ queryString, queryValuesArray, database, tableSchema, debug, }: Param): Promise<any>;
+export {};

dist/package-shared/functions/backend/varReadOnlyDatabaseDbHandler.d.ts

@@ -0,0 +1,12 @@
+type Param = {
+    queryString: string;
+    queryValuesArray?: string[];
+    tableSchema?: import("../../types").DSQL_TableSchemaType;
+    forceLocal?: boolean;
+};
+/**
+ * # Read Only Db Handler with Varaibles
+ * @returns
+ */
+export default function varReadOnlyDatabaseDbHandler({ queryString, queryValuesArray, tableSchema, forceLocal, }: Param): Promise<any>;
+export {};

dist/package-shared/functions/dsql/db-schema-to-type.d.ts

@@ -0,0 +1,6 @@
+import { DSQL_DatabaseSchemaType } from "../../types";
+type Params = {
+    dbSchema?: DSQL_DatabaseSchemaType;
+};
+export default function dbSchemaToType(params?: Params): string[] | undefined;
+export {};

dist/package-shared/functions/dsql/decrypt.d.ts

@@ -0,0 +1,10 @@
+type Param = {
+    encryptedString: string;
+    encryptionKey?: string;
+    encryptionSalt?: string;
+};
+/**
+ * # Decrypt Function
+ */
+export default function decrypt({ encryptedString, encryptionKey, encryptionSalt, }: Param): string;
+export {};

dist/package-shared/functions/dsql/default-fields-regexp.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check for user in local storage
+ *
+ * @description Preventdefault, declare variables
+ */
+declare const defaultFieldsRegexp: RegExp;
+export default defaultFieldsRegexp;

dist/package-shared/functions/dsql/encrypt.d.ts

@@ -0,0 +1,10 @@
+type Param = {
+    data: string;
+    encryptionKey?: string;
+    encryptionSalt?: string;
+};
+/**
+ * # Encrypt String
+ */
+export default function encrypt({ data, encryptionKey, encryptionSalt, }: Param): string | null;
+export {};

dist/package-shared/functions/dsql/generate-type-definitions.d.ts

@@ -0,0 +1,11 @@
+import { DSQL_TableSchemaType } from "../../types";
+type Param = {
+    paradigm: "JavaScript" | "TypeScript" | undefined;
+    table: DSQL_TableSchemaType;
+    query?: any;
+    typeDefName?: string;
+    allValuesOptional?: boolean;
+    addExport?: boolean;
+};
+export default function generateTypeDefinition({ paradigm, table, query, typeDefName, allValuesOptional, addExport, }: Param): string | null;
+export {};

dist/package-shared/functions/dsql/hashPassword.d.ts

@@ -0,0 +1,9 @@
+type Param = {
+    password: string;
+    encryptionKey?: string;
+};
+/**
+ * # Hash password Function
+ */
+export default function hashPassword({ password, encryptionKey, }: Param): string;
+export {};

dist/package-shared/functions/dsql/sql/sql-delete-generator.d.ts

@@ -0,0 +1,13 @@
+interface SQLDeleteGenReturn {
+    query: string;
+    values: string[];
+}
+/**
+ * # SQL Delete Generator
+ */
+export default function sqlDeleteGenerator({ tableName, data, dbFullName, }: {
+    data: any;
+    tableName: string;
+    dbFullName?: string;
+}): SQLDeleteGenReturn | undefined;
+export {};

dist/package-shared/functions/dsql/sql/sql-generator.d.ts

@@ -0,0 +1,24 @@
+import { ServerQueryParam } from "../../../types";
+type Param<T extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}> = {
+    genObject?: ServerQueryParam<T>;
+    tableName: string;
+    dbFullName?: string;
+};
+type Return = {
+    string: string;
+    values: string[];
+};
+/**
+ * # SQL Query Generator
+ * @description Generates an SQL Query for node module `mysql` or `serverless-mysql`
+ */
+export default function sqlGenerator<T extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}>({ tableName, genObject, dbFullName }: Param<T>): Return;
+export {};

dist/package-shared/functions/dsql/sql/sql-insert-generator.d.ts

@@ -0,0 +1,13 @@
+interface SQLInsertGenReturn {
+    query: string;
+    values: string[];
+}
+/**
+ * # SQL Insert Generator
+ */
+export default function sqlInsertGenerator({ tableName, data, dbFullName, }: {
+    data: any[];
+    tableName: string;
+    dbFullName?: string;
+}): SQLInsertGenReturn | undefined;
+export {};

dist/package-shared/functions/email/fns/validate-email.d.ts

@@ -0,0 +1,10 @@
+import { HandleNodemailerParam } from "../../backend/handleNodemailer";
+type Param = {
+    email?: string;
+    welcomeEmailOptions?: HandleNodemailerParam;
+};
+export default function validateEmail({ email, welcomeEmailOptions, }: Param): Promise<{
+    isValid: boolean;
+    message?: string;
+}>;
+export {};

dist/package-shared/functions/email/verification/email-mx-lookup.d.ts

@@ -0,0 +1 @@
+export default function emailMxLookup(email?: string, debug?: boolean): Promise<boolean>;

dist/package-shared/functions/email/verification/email-regex-test.d.ts

@@ -0,0 +1 @@
+export default function emailRegexCheck(email: string): boolean;

dist/package-shared/functions/email/verification/smtp-verification.d.ts

@@ -0,0 +1 @@
+export default function verifyEmailSMTP(email: string): Promise<boolean>;