skyflow-js 2.4.3 → 2.4.4

package/package.json

@@ -2,7 +2,7 @@
   "name": "skyflow-js",
   "preferGlobal": true,
   "analyze": false,
-  "version": "2.4.3",
+  "version": "2.4.4",
   "author": "Skyflow",
   "description": "Skyflow JavaScript SDK",
   "homepage": "https://github.com/skyflowapi/skyflow-js",

package/types/client/index.d.ts

@@ -1,6 +1,7 @@
 import { ISkyflow } from '../skyflow';
+import { ClientMetadata } from '../core/internal/internal-types';
 export interface IClientRequest {
-    body?: any;
+    body?: Document | XMLHttpRequestBodyInit | null;
     headers?: Record<string, string>;
     requestMethod: 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'PATCH';
     url: string;
@@ -9,15 +10,16 @@ export interface SdkInfo {
     sdkName: string;
     sdkVersion: string;
 }
+export interface ClientToJSON {
+    config: ISkyflow;
+    metaData: ClientMetadata;
+}
 declare class Client {
     #private;
     config: ISkyflow;
-    constructor(config: ISkyflow, metadata: any);
-    toJSON(): {
-        config: ISkyflow;
-        metaData: any;
-    };
-    static fromJSON(json: any): Client;
+    constructor(config: ISkyflow, metadata: ClientMetadata);
+    toJSON(): ClientToJSON;
+    static fromJSON(json: ClientToJSON): Client;
     request: (request: IClientRequest) => Promise<unknown>;
 }
 export default Client;

package/types/core/external/collect/collect-container.d.ts

@@ -1,12 +1,38 @@
-import { CollectElementInput, CollectElementOptions, CollectResponse, ICollectOptions, UploadFilesResponse } from '../../../utils/common';
+import { Context, CollectElementInput, CollectElementOptions, CollectResponse, ICollectOptions, UploadFilesResponse, ContainerOptions } from '../../../utils/common';
+import { ElementType } from '../../constants';
 import Container from '../common/container';
 import CollectElement from './collect-element';
+import { Metadata, SkyflowElementProps } from '../../internal/internal-types';
+export interface ICollectElement {
+    elementType: ElementType;
+    elementName: string;
+    name: string;
+    table?: string;
+    column?: string;
+    sensitive?: boolean;
+    replacePattern?: RegExp;
+    mask?: string[];
+    value?: string;
+    isMounted: boolean;
+    [key: string]: unknown;
+}
+export interface ElementGroupItem extends CollectElementInput, CollectElementOptions {
+    elementType: ElementType;
+    name?: string;
+    accept?: string[];
+    elementName?: string;
+}
+export interface ElementGroup {
+    rows: Array<{
+        elements: Array<ElementGroupItem>;
+    }>;
+}
 declare class CollectContainer extends Container {
     #private;
     type: string;
-    constructor(options: any, metaData: any, skyflowElements: any, context: any);
+    constructor(metaData: Metadata, skyflowElements: Array<SkyflowElementProps>, context: Context, options?: ContainerOptions);
     create: (input: CollectElementInput, options?: CollectElementOptions) => CollectElement;
     collect: (options?: ICollectOptions) => Promise<CollectResponse>;
-    uploadFiles: (options: ICollectOptions) => Promise<UploadFilesResponse>;
+    uploadFiles: (options?: ICollectOptions) => Promise<UploadFilesResponse>;
 }
 export default CollectContainer;

package/types/core/external/collect/collect-element.d.ts

@@ -1,18 +1,21 @@
 import EventEmitter from '../../../event-emitter';
 import { CollectElementUpdateOptions, Context } from '../../../utils/common';
 import SkyflowElement from '../common/skyflow-element';
+import { Metadata, ContainerProps } from '../../internal/internal-types';
 declare class CollectElement extends SkyflowElement {
     #private;
     elementType: string;
     type: string;
     containerId: string;
     resizeObserver: ResizeObserver | null;
-    constructor(elementId: string, elementGroup: any, metaData: any, container: any, isSingleElementAPI: boolean | undefined, destroyCallback: Function, updateCallback: Function, context: Context, groupEventEmitter?: EventEmitter);
+    constructor(elementId: string, elementGroup: any, metaData: Metadata, container: ContainerProps, isSingleElementAPI: boolean | undefined, destroyCallback: Function, updateCallback: Function, context: Context, groupEventEmitter?: EventEmitter);
     getID: () => string;
     mount: (domElement: HTMLElement | string) => void;
     unmount: () => void;
     updateElementGroup: (group: any) => void;
-    updateElement: (elementOptions: any) => void;
+    updateElement: (elementOptions: {
+        elementName: string;
+    } & CollectElementUpdateOptions) => void;
     update: (options: CollectElementUpdateOptions) => void;
     getState: () => {
         isEmpty: boolean;

package/types/core/external/collect/compose-collect-container.d.ts

@@ -1,10 +1,16 @@
-import { CollectElementInput, CollectElementOptions, ICollectOptions, CollectResponse } from '../../../utils/common';
+import { Context, CollectElementInput, CollectElementOptions, ICollectOptions, CollectResponse, InputStyles, ErrorTextStyles, ContainerOptions } from '../../../utils/common';
 import Container from '../common/container';
 import ComposableElement from './compose-collect-element';
+import { ElementGroup } from './collect-container';
+import { Metadata, SkyflowElementProps } from '../../internal/internal-types';
+export interface ComposableElementGroup extends ElementGroup {
+    styles: InputStyles;
+    errorTextStyles: ErrorTextStyles;
+}
 declare class ComposableContainer extends Container {
     #private;
     type: string;
-    constructor(options: any, metaData: any, skyflowElements: any, context: any);
+    constructor(metaData: Metadata, skyflowElements: Array<SkyflowElementProps>, context: Context, options: ContainerOptions);
     create: (input: CollectElementInput, options?: CollectElementOptions) => ComposableElement;
     on: (eventName: string, handler: Function) => void;
     mount: (domElement: HTMLElement | string) => void;

package/types/core/external/collect/compose-collect-element.d.ts

@@ -1,8 +1,9 @@
+import EventEmitter from '../../../event-emitter';
 import { CollectElementUpdateOptions } from '../../../utils/common';
 declare class ComposableElement {
     #private;
     type: string;
-    constructor(name: any, eventEmitter: any, iframeName: any);
+    constructor(name: string, eventEmitter: EventEmitter, iframeName: string);
     on(eventName: string, handler: Function): void;
     iframeName(): string;
     getID(): string;

package/types/core/external/common/iframe.d.ts

@@ -1,10 +1,12 @@
+import { LogLevel } from '../../../index-node';
+import { Metadata } from '../../internal/internal-types';
 export default class IFrame {
     name: string;
-    metadata: any;
+    metadata: Metadata;
     iframe: HTMLIFrameElement;
     container?: Element;
-    constructor(name: any, metadata: any, containerId: any, logLevel: any);
-    mount: (domElement: any, elementId?: string, data?: any) => void;
+    constructor(name: string, metadata: Metadata, containerId: string, logLevel: LogLevel);
+    mount: (domElement: HTMLElement | string, elementId?: string, data?: any) => void;
     setIframeHeight: (height: any) => void;
     unmount: () => void;
 }

package/types/core/external/common/skyflow-element.d.ts

@@ -1,10 +1,10 @@
 declare abstract class SkyflowElement {
-    abstract mount(domElementSelector: any): any;
-    abstract unmount(): any;
-    abstract setError(clientErrorText: string): any;
-    abstract resetError(): any;
-    abstract setErrorOverride(customErrorText: string): any;
-    abstract iframeName(): any;
-    abstract getID(): any;
+    abstract mount(domElementSelector: HTMLElement | string): void;
+    abstract unmount(): void;
+    abstract setError(clientErrorText: string): void;
+    abstract resetError(): void;
+    abstract setErrorOverride(customErrorText: string): void;
+    abstract iframeName(): string;
+    abstract getID(): string;
 }
 export default SkyflowElement;

package/types/core/external/reveal/reveal-container.d.ts

@@ -1,6 +1,7 @@
-import { RedactionType, RevealResponse } from '../../../utils/common';
+import { ContainerOptions, Context, RedactionType, RevealResponse } from '../../../utils/common';
 import Container from '../common/container';
 import RevealElement from './reveal-element';
+import { Metadata, SkyflowElementProps } from '../../internal/internal-types';
 export interface IRevealElementInput {
     token?: string;
     skyflowID?: string;
@@ -21,7 +22,7 @@ export interface IRevealElementOptions {
 declare class RevealContainer extends Container {
     #private;
     type: string;
-    constructor(metaData: any, skyflowElements: any, context: any, options?: {});
+    constructor(metaData: Metadata, skyflowElements: Array<SkyflowElementProps>, context: Context, options?: ContainerOptions);
     create(record: IRevealElementInput, options?: IRevealElementOptions): RevealElement;
     reveal(): Promise<RevealResponse>;
 }

package/types/core/external/reveal/reveal-element.d.ts

@@ -1,9 +1,10 @@
 import { Context, RenderFileResponse } from '../../../utils/common';
 import SkyflowElement from '../common/skyflow-element';
 import { IRevealElementInput, IRevealElementOptions } from './reveal-container';
+import { Metadata, RevealContainerProps } from '../../internal/internal-types';
 declare class RevealElement extends SkyflowElement {
     #private;
-    constructor(record: IRevealElementInput, options: IRevealElementOptions | undefined, metaData: any, container: any, elementId: string, context: Context);
+    constructor(record: IRevealElementInput, options: IRevealElementOptions | undefined, metaData: Metadata, container: RevealContainerProps, elementId: string, context: Context);
     getID(): string;
     mount(domElementSelector: HTMLElement | string): void;
     renderFile(): Promise<RenderFileResponse>;

package/types/core/external/skyflow-container.d.ts

@@ -1,8 +1,9 @@
-import { IDetokenizeInput, IGetInput, IGetByIdInput, IInsertOptions, IDeleteOptions, IDeleteRecordInput, IGetOptions, InsertResponse, GetByIdResponse, GetResponse, DeleteResponse, IInsertRecordInput, DetokenizeResponse } from '../../utils/common';
+import Client from '../../client';
+import { IDetokenizeInput, IGetInput, Context, IGetByIdInput, IInsertOptions, IDeleteOptions, IDeleteRecordInput, IGetOptions, InsertResponse, GetByIdResponse, GetResponse, DeleteResponse, IInsertRecordInput, DetokenizeResponse } from '../../utils/common';
 declare class SkyflowContainer {
     #private;
     isControllerFrameReady: boolean;
-    constructor(client: any, context: any);
+    constructor(client: Client, context: Context);
     detokenize(detokenizeInput: IDetokenizeInput): Promise<DetokenizeResponse>;
     insert(records: IInsertRecordInput, options?: IInsertOptions): Promise<InsertResponse>;
     getById(getByIdInput: IGetByIdInput): Promise<GetByIdResponse>;

package/types/core/internal/internal-types/index.d.ts

@@ -0,0 +1,72 @@
+import { ClientToJSON } from '../../../client';
+import EventEmitter from '../../../event-emitter';
+import { CollectContainer, ComposableContainer, RevealContainer } from '../../../index-node';
+import { ContainerType } from '../../../skyflow';
+import { CollectElementOptions, ICollectOptions } from '../../../utils/common';
+import { ElementType } from '../../constants';
+import SkyflowContainer from '../../external/skyflow-container';
+export interface ElementInfo {
+    frameId: string;
+    elementId: string;
+}
+export interface TokenizeDataInput extends ICollectOptions {
+    type: string;
+    elementIds: Array<ElementInfo>;
+    containerId: string;
+}
+export interface UploadFileDataInput extends ICollectOptions {
+    type: string;
+    elementIds: Array<string>;
+    containerId: string;
+}
+export interface BatchInsertRequestBody {
+    method: string;
+    quorum?: boolean;
+    tableName: string;
+    fields?: Record<string, any>;
+    upsert?: string;
+    ID?: string;
+    tokenization?: boolean;
+    [key: string]: any;
+}
+export interface ContainerProps {
+    containerId: string;
+    isMounted: boolean;
+    type: string;
+}
+export interface RevealContainerProps {
+    containerId: string;
+    isMounted: boolean;
+    eventEmitter: EventEmitter;
+}
+export interface InternalState {
+    isEmpty: boolean;
+    isValid: boolean;
+    isFocused: boolean;
+    isRequired: boolean;
+    name: string;
+    elementType: ElementType;
+    isComplete: boolean;
+    value: string | Blob | undefined;
+    selectedCardScheme: string;
+}
+export interface FormattedCollectElementOptions extends CollectElementOptions {
+    [key: string]: any;
+}
+export interface SkyflowElementProps {
+    id: string;
+    type: ElementType;
+    element: HTMLElement;
+    container: CollectContainer | RevealContainer | ComposableContainer;
+}
+export interface ClientMetadata {
+    uuid: string;
+    clientDomain: string;
+    sdkVersion?: string;
+    sessionId?: string;
+}
+export interface Metadata extends ClientMetadata {
+    clientJSON: ClientToJSON;
+    containerType: ContainerType;
+    skyflowContainer: SkyflowContainer;
+}

package/types/core/internal/skyflow-frame/skyflow-frame-controller.d.ts

@@ -1,13 +1,15 @@
-import { IRevealRecord } from '../../../utils/common';
+import { IRevealRecord, IInsertRecordInput, IInsertOptions, UploadFilesResponse, RevealResponse, InsertResponse, CollectResponse, IRenderResponseType } from '../../../utils/common';
+import { TokenizeDataInput, UploadFileDataInput } from '../internal-types';
+import IFrameFormElement from '../iframe-form';
 declare class SkyflowFrameController {
     #private;
     constructor(clientId: string);
-    static init(clientId: any): SkyflowFrameController;
-    revealData(revealRecords: IRevealRecord[], containerId: any): Promise<unknown>;
-    insertData(records: any, options: any): Promise<unknown>;
-    renderFile(data: any, iframeName: any): Promise<unknown>;
-    tokenize: (options: any) => Promise<unknown>;
-    parallelUploadFiles: (options: any) => Promise<unknown>;
-    uploadFiles: (fileElement: any) => Promise<unknown>;
+    static init(clientId: string): SkyflowFrameController;
+    revealData(revealRecords: IRevealRecord[], containerId: string): Promise<RevealResponse>;
+    insertData(records: IInsertRecordInput, options: IInsertOptions): Promise<InsertResponse>;
+    renderFile(data: IRevealRecord, iframeName: string): Promise<IRenderResponseType>;
+    tokenize: (options: TokenizeDataInput) => Promise<CollectResponse>;
+    parallelUploadFiles: (options: UploadFileDataInput) => Promise<UploadFilesResponse>;
+    uploadFiles: (fileElement: IFrameFormElement) => Promise<unknown>;
 }
 export default SkyflowFrameController;

package/types/core-utils/collect.d.ts

@@ -1,15 +1,14 @@
 import Client from '../client';
-import { IInsertRecordInput, IInsertRecord, IValidationRule } from '../utils/common';
+import { IInsertRecordInput, IInsertRecord, IValidationRule, InsertResponse } from '../utils/common';
 import IFrameFormElement from '../core/internal/iframe-form';
+import { BatchInsertRequestBody } from '../core/internal/internal-types';
 export interface IUpsertOptions {
     table: string;
     column: string;
 }
 export declare const getUpsertColumn: (tableName: string, options: Array<IUpsertOptions> | undefined) => string;
-export declare const constructInsertRecordRequest: (records: IInsertRecordInput, options?: Record<string, any>) => any;
-export declare const constructInsertRecordResponse: (responseBody: any, tokens: boolean, records: IInsertRecord[]) => {
-    records: any;
-};
+export declare const constructInsertRecordRequest: (records: IInsertRecordInput, options?: Record<string, any>) => Array<BatchInsertRequestBody>;
+export declare const constructInsertRecordResponse: (responseBody: any, tokens: boolean, records: IInsertRecord[]) => InsertResponse;
 export declare const constructFinalUpdateRecordResponse: (responseBody: any, tokens: boolean, records: any) => {
     table: any;
     fields: any;

package/types/core-utils/delete.d.ts

@@ -1,4 +1,4 @@
 import Client from '../client';
-import { IDeleteRecord, IDeleteResponseType } from '../utils/common';
+import { IDeleteOptions, IDeleteRecord, IDeleteRecordInput, IDeleteResponseType } from '../utils/common';
 export declare const deleteRecordsFromVault: (record: IDeleteRecord, authToken: String, client: Client) => Promise<any>;
-export declare const deleteData: (records: any, options: any, client: any) => Promise<IDeleteResponseType>;
+export declare const deleteData: (records: IDeleteRecordInput, options: IDeleteOptions, client: Client) => Promise<IDeleteResponseType>;

package/types/core-utils/reveal.d.ts

@@ -1,5 +1,5 @@
 import Client from '../client';
-import { IRevealRecord, IRevealResponseType, IGetRecord, ISkyflowIdRecord, IRenderResponseType, IGetOptions, RenderFileResponse } from '../utils/common';
+import { IRevealRecord, IRevealResponseType, IGetRecord, ISkyflowIdRecord, IRenderResponseType, IGetOptions, RenderFileResponse, RevealResponse, GetResponse, GetByIdResponse } from '../utils/common';
 export declare const getFileURLForRender: (skyflowIdRecord: IRevealRecord, client: Client, authToken: string) => Promise<any>;
 export declare const getFileURLFromVaultBySkyflowID: (skyflowIdRecord: IRevealRecord, client: Client) => Promise<IRenderResponseType>;
 export declare const fetchRecordsByTokenId: (tokenIdRecords: IRevealRecord[], client: Client) => Promise<IRevealResponseType>;
@@ -10,21 +10,6 @@ export declare const formatRecordsForRender: (response: IRenderResponseType, col
     url: string;
 };
 export declare const formatForRenderClient: (response: IRenderResponseType, column: string) => RenderFileResponse;
-export declare const formatRecordsForClient: (response: IRevealResponseType) => {
-    success: {
-        token: string;
-        valueType: string;
-    }[];
-    errors: Record<string, any>[];
-} | {
-    success: {
-        token: string;
-        valueType: string;
-    }[];
-    errors?: undefined;
-} | {
-    errors: Record<string, any>[] | undefined;
-    success?: undefined;
-};
-export declare const fetchRecordsGET: (skyflowIdRecords: IGetRecord[], client: Client, options?: IGetOptions) => Promise<unknown>;
-export declare const fetchRecordsBySkyflowID: (skyflowIdRecords: ISkyflowIdRecord[], client: Client) => Promise<unknown>;
+export declare const formatRecordsForClient: (response: IRevealResponseType) => RevealResponse;
+export declare const fetchRecordsGET: (skyflowIdRecords: IGetRecord[], client: Client, options?: IGetOptions) => Promise<GetResponse>;
+export declare const fetchRecordsBySkyflowID: (skyflowIdRecords: ISkyflowIdRecord[], client: Client) => Promise<GetByIdResponse>;

package/types/libs/element-options.d.ts

@@ -1,7 +1,9 @@
-import { IValidationRule } from '../utils/common';
+import { ElementType } from '../core/constants';
+import { FormattedCollectElementOptions } from '../core/internal/internal-types';
+import { CollectElementOptions, IValidationRule, LogLevel } from '../utils/common';
 export declare function validateElementOptions(elementType: string, oldOptions: any, newOptions?: any): void;
 export declare function validateAndSetupGroupOptions(oldGroup: any, newGroup?: any, setup?: boolean): any;
 export declare const getElements: (group: any) => string[];
 export declare const getValueAndItsUnit: (string?: string, defaultValue?: string, defaultUnit?: string) => string[];
 export declare const formatValidations: (validations?: IValidationRule[]) => IValidationRule[] | undefined;
-export declare const formatOptions: (elementType: any, options: any, logLevel: any) => any;
+export declare const formatOptions: (elementType: ElementType, options: CollectElementOptions, logLevel: LogLevel) => FormattedCollectElementOptions;

package/types/libs/jss-styles.d.ts

@@ -1,2 +1,2 @@
-export default function getCssClassesFromJss(styles: any, name: any): import("jss").Classes<string | number | symbol>;
+export default function getCssClassesFromJss(styles: any, name: string): import("jss").Classes<string | number | symbol>;
 export declare function generateCssWithoutClass(styles: any): import("jss").Classes<string | number | symbol>;

package/types/skyflow.d.ts

@@ -10,11 +10,18 @@ export declare enum ContainerType {
     REVEAL = "REVEAL",
     COMPOSABLE = "COMPOSABLE"
 }
+export interface SkyflowConfigOptions {
+    logLevel?: LogLevel;
+    env?: Env;
+    trackingKey?: string;
+    trackMetrics?: boolean;
+    customElementsURL?: string;
+}
 export interface ISkyflow {
     vaultID?: string;
     vaultURL?: string;
     getBearerToken: () => Promise<string>;
-    options?: Record<string, any>;
+    options?: SkyflowConfigOptions;
 }
 declare class Skyflow {
     #private;

package/types/utils/bus-events/index.d.ts

@@ -1,2 +1,2 @@
-export declare function getAccessToken(clientId: any): Promise<unknown>;
+export declare function getAccessToken(clientId: string): Promise<unknown>;
 export declare function updateElementState(frameName: string, value: any): void;

package/types/utils/common/index.d.ts

@@ -167,6 +167,7 @@ export interface DetokenizeResponse extends IRevealResponseType {
 export interface InsertResponseRecords {
     fields: Record<string, any>;
     table: string;
+    skyflow_id?: string;
 }
 export interface ErrorRecord {
     code: number;
@@ -261,22 +262,18 @@ export interface ICollectOptions {
     upsert?: Array<IUpsertOptions>;
 }
 export interface UploadFilesResponse {
-    fileUploadResponse: [{
-        skyflow_id: string;
-    }];
-    errorResponse: [{
-        error: ErrorRecord;
-    }];
+    fileUploadResponse?: Record<string, any>;
+    errorResponse?: Record<string, any>;
 }
 export interface RevealResponse {
-    success?: {
+    success?: Array<{
         token: string;
         valueType: string;
-    };
-    errors?: {
+    }>;
+    errors?: Array<{
         error: ErrorRecord;
         token: string;
-    };
+    }>;
 }
 export interface RenderFileResponse {
     success?: {

package/types/utils/helpers/index.d.ts

@@ -4,19 +4,19 @@ import { ContainerType, ISkyflow } from '../../skyflow';
 export declare const flattenObject: (obj: any, roots?: any, sep?: string) => any;
 export declare function formatFrameNameToId(name: string): string;
 export declare function removeSpaces(inputString: string): string;
-export declare function formatVaultURL(vaultURL: any): any;
+export declare function formatVaultURL(vaultURL?: string): string | undefined;
 export declare function checkIfDuplicateExists(arr: any): boolean;
-export declare const appendZeroToOne: (value: any) => {
+export declare const appendZeroToOne: (value: string) => {
     isAppended: boolean;
-    value: any;
+    value: string;
 };
-export declare const appendMonthFourDigitYears: (value: any) => {
+export declare const appendMonthFourDigitYears: (value: string) => {
     isAppended: boolean;
-    value: any;
+    value: string;
 };
-export declare const appendMonthTwoDigitYears: (value: any) => {
+export declare const appendMonthTwoDigitYears: (value: string) => {
     isAppended: boolean;
-    value: any;
+    value: string;
 };
 export declare const getReturnValue: (value: string | Blob, element: string, doesReturnValue: boolean) => string | Blob | undefined;
 export declare function domReady(fn: any): void;
@@ -27,7 +27,7 @@ export declare const getMaskedOutput: (input: string, format: string, translatio
 export declare const copyToClipboard: (text: string) => void;
 export declare const handleCopyIconClick: (textToCopy: string, domCopy: any) => void;
 export declare const fileValidation: (value: any, required: Boolean | undefined, fileElement: any) => boolean;
-export declare const vaildateFileName: (name: any) => boolean;
+export declare const vaildateFileName: (name: string) => boolean;
 export declare const styleToString: (style: any) => string;
 export declare const getContainerType: (frameName: string) => ContainerType;
 export declare const addSeperatorToCardNumberMask: (cardNumberMask: any, seperator?: string) => any;

package/types/utils/validators/index.d.ts

@@ -1,7 +1,7 @@
 import { CardType } from '../../core/constants';
 import { IRevealElementInput } from '../../core/external/reveal/reveal-container';
 import { ISkyflow } from '../../skyflow';
-import { IInsertRecordInput, IDetokenizeInput, IGetInput, IGetByIdInput, IDeleteRecordInput, IGetOptions, CollectElementInput } from '../common';
+import { IInsertRecordInput, IDetokenizeInput, IGetInput, IGetByIdInput, IDeleteRecordInput, IGetOptions, CollectElementInput, LogLevel, ContainerOptions } from '../common';
 export declare const validateCreditCardNumber: (cardNumber: string) => boolean;
 export declare const detectCardType: (cardNumber?: string) => CardType.DEFAULT;
 export declare const validateExpiryDate: (date: string, format: string) => boolean;
@@ -21,8 +21,8 @@ export declare const isValidURL: (url: string) => boolean;
 export declare const isValidRegExp: (input: any) => boolean;
 export declare const validateCardNumberLengthCheck: (cardNumber?: string) => boolean;
 export declare const validateInitConfig: (initConfig: ISkyflow) => void;
-export declare const validateCollectElementInput: (input: CollectElementInput, logLevel: any) => void;
+export declare const validateCollectElementInput: (input: CollectElementInput, logLevel: LogLevel) => void;
 export declare const validateUpsertOptions: (upsertOptions: any) => void;
-export declare const validateComposableContainerOptions: (options: any) => void;
+export declare const validateComposableContainerOptions: (options: ContainerOptions) => void;
 export declare const validateBooleanOptions: (option: any) => boolean;
 export declare const validateInputFormatOptions: (options: any) => void;