skyflow-js 2.5.0-beta.9 → 2.6.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "skyflow-js",
   "preferGlobal": true,
   "analyze": false,
-  "version": "2.5.0-beta.9",
+  "version": "2.6.0",
   "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/constants.d.ts

@@ -65,6 +65,7 @@ export declare const PUREJS_TYPES: {
     GET_BY_SKYFLOWID: string;
     GET: string;
     DELETE: string;
+    UPDATE: string;
 };
 export declare const COLLECT_TYPES: {
     COLLECT: string;

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, UploadFilesResponse } from '../../../utils/common';
+import { Context, CollectElementInput, CollectElementOptions, ICollectOptions, CollectResponse, InputStyles, ErrorTextStyles, ContainerOptions, UploadFilesResponse } 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/common/iframe.d.ts

@@ -1,9 +1,11 @@
+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);
+    constructor(name: string, metadata: Metadata, containerId: string, logLevel: LogLevel);
     mount: (domElement: any, 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/composable-reveal-container.d.ts

@@ -1,11 +1,13 @@
+import { Context } from '../../../utils/common';
 import Container from '../common/container';
 import ComposableRevealElement from './composable-reveal-element';
-import { RevealElementInput, RevealResponse } from '../../../index-node';
+import { ContainerOptions, RevealElementInput, RevealResponse } from '../../../index-node';
 import { IRevealElementOptions } from './reveal-container';
+import { Metadata, SkyflowElementProps } from '../../internal/internal-types';
 declare class ComposableRevealContainer 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: RevealElementInput, options?: IRevealElementOptions) => ComposableRevealElement;
     mount: (domElement: HTMLElement | string) => void;
     unmount: () => void;

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

@@ -1,9 +1,10 @@
+import EventEmitter from '../../../event-emitter';
 import { RenderFileResponse } from '../../../utils/common';
 import { IRevealElementInput, IRevealElementOptions } from './reveal-container';
 declare class ComposableRevealElement {
     #private;
     type: string;
-    constructor(name: any, eventEmitter: any, iframeName: any);
+    constructor(name: string, eventEmitter: EventEmitter, iframeName: string);
     iframeName(): string;
     getID(): string;
     renderFile(): Promise<RenderFileResponse>;

package/types/core/external/reveal/composable-reveal-internal.d.ts

@@ -1,28 +1,28 @@
 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';
 export interface RevealComposableGroup {
     record: IRevealElementInput;
     options: IRevealElementOptions;
 }
 declare class ComposableRevealInternalElement extends SkyflowElement {
     #private;
-    constructor(elementId: string, recordGroup: RevealComposableGroup[], metaData: any, container: any, isSingleElementAPI: boolean | undefined, context: Context);
+    resizeObserver: ResizeObserver | null;
+    constructor(elementId: string, recordGroup: any, metaData: Metadata, container: RevealContainerProps, context: Context);
     private setupRenderFileEventListener;
     getID(): string;
     mount(domElementSelector: HTMLElement | string): void;
     renderFile(recordData: any): Promise<RenderFileResponse>;
     iframeName(): string;
     isMounted(): boolean;
-    hasToken(): boolean;
     isClientSetError(): boolean;
     getRecordData(): any;
     setErrorOverride(clientErrorText: string): void;
     setError(clientErrorText: string): void;
     resetError(): void;
-    setAltText(altText: string): void;
+    setAltText(altText: string, record: any): void;
     clearAltText(): void;
-    setToken(token: string): void;
     unmount(): void;
     update(options: IRevealElementInput | IRevealElementOptions, record: any): void;
 }

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,10 +1,12 @@
-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, IUpdateRequest, UpdateResponse, IUpdateOptions } 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>;
+    update(record: IUpdateRequest, options?: IUpdateOptions): Promise<UpdateResponse>;
     getById(getByIdInput: IGetByIdInput): Promise<GetByIdResponse>;
     get(getInput: IGetInput, options?: IGetOptions): Promise<GetResponse>;
     delete(records: IDeleteRecordInput, options?: IDeleteOptions): Promise<DeleteResponse>;

package/types/core/internal/composable-frame-element-init.d.ts

@@ -16,6 +16,6 @@ export default class RevealComposableFrameElementInit {
     constructor();
     updateGroupData: () => void;
     static startFrameElement: () => void;
-    revealData(revealRecords: IRevealRecordComposable[], containerId: any, authToken: any): Promise<unknown>;
+    revealData(revealRecords: IRevealRecordComposable[], containerId: string, authToken: string): Promise<unknown>;
     createContainerDiv: (newGroup: any) => void;
 }

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

@@ -0,0 +1,75 @@
+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;
+    type: string;
+}
+export interface InternalState {
+    metaData: any;
+    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;
+    getSkyflowBearerToken: () => Promise<string>;
+}

package/types/core/internal/reveal/reveal-frame.d.ts

@@ -1,10 +1,11 @@
+import { Context } from '../../../utils/common';
 declare class RevealFrame {
     #private;
     static revealFrame: RevealFrame;
     private domCopy?;
     private isRevealCalled?;
     static init(): void;
-    constructor(record: any, context: any, id: any, rootDiv?: any);
+    constructor(record: any, context: Context, id: string, rootDiv?: HTMLDivElement);
     responseUpdate: (data: any) => void;
     getConfig: () => void;
     getData: () => any;

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

@@ -1,13 +1,16 @@
-import { IRevealRecord } from '../../../utils/common';
+import { IRevealRecord, IInsertRecordInput, IInsertOptions, UploadFilesResponse, RevealResponse, InsertResponse, CollectResponse, IRenderResponseType, IUpdateRequest, UpdateResponse, IUpdateOptions } 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>;
+    updateData(updateData: IUpdateRequest, options?: IUpdateOptions): Promise<UpdateResponse>;
+    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,21 @@
 import Client from '../client';
-import { IInsertRecordInput, IInsertRecord, IValidationRule } from '../utils/common';
+import { IInsertRecordInput, IInsertRecord, IValidationRule, InsertResponse, IUpdateRequest, IUpdateOptions, UpdateResponse } 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 constructUpdateRecordRequest: (updateData: IUpdateRequest, options?: IUpdateOptions) => {
+    record: {
+        fields: Record<string, unknown>;
+    };
+    tokenization: boolean;
 };
+export declare const constructUpdateRecordResponse: (responseBody: any, tokenization: boolean) => UpdateResponse;
 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, IRevealRecordComposable } from '../utils/common';
+import { IRevealRecord, IRevealResponseType, IGetRecord, ISkyflowIdRecord, IRenderResponseType, IGetOptions, RenderFileResponse, RevealResponse, GetResponse, GetByIdResponse, IRevealRecordComposable } 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 getFileURLFromVaultBySkyflowIDComposable: (skyflowIdRecord: IRevealRecord, client: Client, authToken: string) => Promise<IRenderResponseType>;
@@ -12,22 +12,7 @@ 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 formatRecordsForClient: (response: IRevealResponseType) => RevealResponse;
 export declare const formatRecordsForClientComposable: (response: any) => {
     success: never[];
     errors: never[];
@@ -38,5 +23,5 @@ export declare const formatRecordsForClientComposable: (response: any) => {
     errors: never[];
     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 fetchRecordsGET: (skyflowIdRecords: IGetRecord[], client: Client, options?: IGetOptions) => Promise<GetResponse>;
+export declare const fetchRecordsBySkyflowID: (skyflowIdRecords: ISkyflowIdRecord[], client: Client) => Promise<GetByIdResponse>;

package/types/index-node.d.ts

@@ -1,5 +1,5 @@
 import Skyflow from './skyflow';
-export { IInsertRecordInput as InsertRequest, IInsertRecord as InsertRecord, IInsertOptions as InsertOptions, InsertResponse, IDetokenizeInput as DetokenizeRequest, DetokenizeRecord, DetokenizeResponse, IDeleteRecordInput as DeleteRequest, IDeleteRecord as DeleteRecord, IDeleteOptions as DeleteOptions, DeleteResponse, IGetInput as GetRequest, IGetRecord as GetRecord, IGetOptions as GetOptions, GetResponse, IGetByIdInput as GetByIdRequest, GetByIdResponse, ContainerOptions, CollectElementInput, CollectElementUpdateOptions, CollectElementOptions, ICollectOptions as CollectOptions, CollectResponse, UploadFilesResponse, CardMetadata, InputStyles, LabelStyles, ErrorTextStyles, RedactionType, IRevealRecord as RevealRecord, RevealResponse, RenderFileResponse, IValidationRule as ValidationRule, ValidationRuleType, EventName, LogLevel, Env, ElementState, } from './utils/common';
+export { IInsertRecordInput as InsertRequest, IInsertRecord as InsertRecord, IInsertOptions as InsertOptions, IUpdateRequest as UpdateRequest, IUpdateOptions as UpdateOptions, UpdateResponse, InsertResponse, IDetokenizeInput as DetokenizeRequest, DetokenizeRecord, DetokenizeResponse, IDeleteRecordInput as DeleteRequest, IDeleteRecord as DeleteRecord, IDeleteOptions as DeleteOptions, DeleteResponse, IGetInput as GetRequest, IGetRecord as GetRecord, IGetOptions as GetOptions, GetResponse, IGetByIdInput as GetByIdRequest, GetByIdResponse, ContainerOptions, CollectElementInput, CollectElementUpdateOptions, CollectElementOptions, ICollectOptions as CollectOptions, CollectResponse, UploadFilesResponse, CardMetadata, InputStyles, LabelStyles, ErrorTextStyles, RedactionType, IRevealRecord as RevealRecord, RevealResponse, RenderFileResponse, IValidationRule as ValidationRule, ValidationRuleType, EventName, LogLevel, Env, ElementState, } from './utils/common';
 export { IRevealElementInput as RevealElementInput, IRevealElementOptions as RevealElementOptions, } from './core/external/reveal/reveal-container';
 export { ThreeDSBrowserDetails } from './core/external/threeds/threeds';
 export { CardType, ElementType, } from './core/constants';
@@ -11,4 +11,6 @@ export { default as ComposableElement } from './core/external/collect/compose-co
 export { default as RevealContainer } from './core/external/reveal/reveal-container';
 export { default as RevealElement } from './core/external/reveal/reveal-element';
 export { default as ThreeDS } from './core/external/threeds/threeds';
+export { default as ComposableRevealContainer } from './core/external/reveal/composable-reveal-container';
+export { default as ComposableRevealElement } from './core/external/reveal/composable-reveal-element';
 export default Skyflow;

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

@@ -2,7 +2,7 @@ import { ElementType, CardType } from './core/constants';
 import RevealContainer from './core/external/reveal/reveal-container';
 import CollectContainer from './core/external/collect/collect-container';
 import SkyflowError from './libs/skyflow-error';
-import { RequestMethod, IInsertRecordInput, IDetokenizeInput, IGetInput, RedactionType, EventName, Env, LogLevel, ValidationRuleType, IGetByIdInput, IInsertOptions, IDeleteRecordInput, IDeleteOptions, IGetOptions, InsertResponse, GetResponse, GetByIdResponse, DeleteResponse, ContainerOptions, DetokenizeResponse } from './utils/common';
+import { RequestMethod, IInsertRecordInput, IDetokenizeInput, IGetInput, RedactionType, EventName, Env, LogLevel, ValidationRuleType, IGetByIdInput, IInsertOptions, IDeleteRecordInput, IDeleteOptions, IGetOptions, InsertResponse, GetResponse, GetByIdResponse, DeleteResponse, ContainerOptions, DetokenizeResponse, IUpdateRequest, UpdateResponse, IUpdateOptions } from './utils/common';
 import ComposableContainer from './core/external/collect/compose-collect-container';
 import ThreeDS from './core/external/threeds/threeds';
 import ComposableRevealContainer from './core/external/reveal/composable-reveal-container';
@@ -12,11 +12,18 @@ export declare enum ContainerType {
     COMPOSABLE = "COMPOSABLE",
     COMPOSE_REVEAL = "COMPOSABLE_REVEAL"
 }
+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;
@@ -31,6 +38,7 @@ declare class Skyflow {
     getById(getByIdInput: IGetByIdInput): Promise<GetByIdResponse>;
     get(getInput: IGetInput, options?: IGetOptions): Promise<GetResponse>;
     delete(records: IDeleteRecordInput, options?: IDeleteOptions): Promise<DeleteResponse>;
+    update(record: IUpdateRequest, options?: IUpdateOptions): Promise<UpdateResponse>;
     static get ContainerType(): typeof ContainerType;
     static get ElementType(): typeof ElementType;
     static get RedactionType(): typeof RedactionType;

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

@@ -53,6 +53,14 @@ export interface IInsertRecord {
     fields: Record<string, any>;
     skyflowID?: string;
 }
+export interface IUpdateRequest {
+    table: string;
+    fields: Record<string, unknown>;
+    skyflowID: string;
+}
+export interface IUpdateOptions {
+    tokens?: boolean;
+}
 export interface IRevealRecord {
     token?: string;
     redaction?: RedactionType;
@@ -167,6 +175,13 @@ export interface InsertResponse {
     records?: InsertResponseRecords[];
     errors?: ErrorRecord[];
 }
+export interface UpdateResponseType {
+    skyflowID: string;
+    [key: string]: unknown;
+}
+export interface UpdateResponse {
+    updatedField: UpdateResponseType;
+}
 export interface CollectResponse extends InsertResponse {
 }
 export interface DetokenizeRecord extends IRevealRecord {
@@ -176,6 +191,7 @@ export interface DetokenizeResponse extends IRevealResponseType {
 export interface InsertResponseRecords {
     fields: Record<string, any>;
     table: string;
+    skyflow_id?: string;
 }
 export interface ErrorRecord {
     code: number;
@@ -272,23 +288,24 @@ export interface ICollectOptions {
 export interface MetaData {
     [key: string]: any;
 }
+export interface EventConfig {
+    authToken: string;
+    vaultURL: string;
+    vaultID: string;
+}
 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?: {