@salesforce/lds-adapters-industries-omnidesigner 0.1.0-dev1

package/dist/es/es2018/types/src/generated/types/BuildJsonOutputRepresentation.d.ts

@@ -0,0 +1,38 @@
+import { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 300;
+export declare const VERSION = "bb83e14b392f6b44d139b299465598e2";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    result: string;
+}
+export type BuildJsonOutputRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialBuildJsonOutputRepresentationNormalizedKeyMetadata = Partial<KeyParams> & $64$luvio_engine_NormalizedKeyMetadata;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: KeyParams): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: KeyParams): BuildJsonOutputRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: BuildJsonOutputRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: BuildJsonOutputRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: BuildJsonOutputRepresentation, existing: BuildJsonOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): BuildJsonOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: BuildJsonOutputRepresentationNormalized, incoming: BuildJsonOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: BuildJsonOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output representation of building json
+ *
+ * Keys:
+ *    result (string): result
+ */
+export interface BuildJsonOutputRepresentationNormalized {
+    /** result */
+    result: string;
+}
+/**
+ * Output representation of building json
+ *
+ * Keys:
+ *    result (string): result
+ */
+export interface BuildJsonOutputRepresentation {
+    result: string;
+}

package/dist/es/es2018/types/src/generated/types/DataMapperExecutionInputDataRepresentationList.d.ts

@@ -0,0 +1,28 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "3af129ed7f1a16e03cc6d0457c36de59";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DataMapperExecutionInputDataRepresentationList, existing: DataMapperExecutionInputDataRepresentationListNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DataMapperExecutionInputDataRepresentationListNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DataMapperExecutionInputDataRepresentationListNormalized, incoming: DataMapperExecutionInputDataRepresentationListNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DataMapperExecutionInputDataRepresentationList, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Data Mapper Simulation Input Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DataMapperExecutionInputDataRepresentationListNormalized {
+    /** List of input data for data mapper to simulate */
+    inputs: Array<string>;
+}
+/**
+ * Data Mapper Simulation Input Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DataMapperExecutionInputDataRepresentationList {
+    inputs: Array<string>;
+}

package/dist/es/es2018/types/src/generated/types/DataMapperExecutionInputRepresentation.d.ts

@@ -0,0 +1,35 @@
+import { DataMapperExecutionInputDataRepresentationList as DataMapperExecutionInputDataRepresentationList_DataMapperExecutionInputDataRepresentationList } from './DataMapperExecutionInputDataRepresentationList';
+import { DataMapperExecutionOptionsRepresentation as DataMapperExecutionOptionsRepresentation_DataMapperExecutionOptionsRepresentation } from './DataMapperExecutionOptionsRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "0d7b6d59c3971ef56c29a18d7e5d573d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DataMapperExecutionInputRepresentation, existing: DataMapperExecutionInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DataMapperExecutionInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DataMapperExecutionInputRepresentationNormalized, incoming: DataMapperExecutionInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DataMapperExecutionInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Data Mapper Simulation Input Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DataMapperExecutionInputRepresentationNormalized {
+    /** Input data for data raptor to simulate */
+    dataMapperInput: DataMapperExecutionInputDataRepresentationList_DataMapperExecutionInputDataRepresentationList;
+    /** Input type for the data raptor to simulate */
+    inputType: string;
+    options: DataMapperExecutionOptionsRepresentation_DataMapperExecutionOptionsRepresentation;
+}
+/**
+ * Data Mapper Simulation Input Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DataMapperExecutionInputRepresentation {
+    dataMapperInput: DataMapperExecutionInputDataRepresentationList_DataMapperExecutionInputDataRepresentationList;
+    inputType: string;
+    options: DataMapperExecutionOptionsRepresentation_DataMapperExecutionOptionsRepresentation;
+}

package/dist/es/es2018/types/src/generated/types/DataMapperExecutionOptionsRepresentation.d.ts

@@ -0,0 +1,49 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "621be4a6064797d6a0531cec9203ddcf";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DataMapperExecutionOptionsRepresentation, existing: DataMapperExecutionOptionsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DataMapperExecutionOptionsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DataMapperExecutionOptionsRepresentationNormalized, incoming: DataMapperExecutionOptionsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DataMapperExecutionOptionsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Data Mapper Simulation Option Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DataMapperExecutionOptionsRepresentationNormalized {
+    /** Ignore Cache option for data mapper to execute */
+    ignoreCache?: boolean;
+    /** Ignore Metadata Cache option for data mapper to execute */
+    ignoreMetadataCache?: boolean;
+    /** Ignore Metadata Permissions option for data raptor to simulate */
+    ignoreMetadataPermissions?: boolean;
+    /** Locale option for data mapper to execute */
+    locale?: string;
+    /** Reset cache option for data raptor to simulate */
+    resetCache?: boolean;
+    /** Ignore commit option for data raptor to simulate */
+    shouldIgnoreCommit?: boolean;
+    /** Legacy response option for data raptor to simulate */
+    shouldSendLegacyResponse?: boolean;
+    /** Without sharing option for data raptor to simulate */
+    withoutSharing?: boolean;
+}
+/**
+ * Data Mapper Simulation Option Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DataMapperExecutionOptionsRepresentation {
+    ignoreCache?: boolean;
+    ignoreMetadataCache?: boolean;
+    ignoreMetadataPermissions?: boolean;
+    locale?: string;
+    resetCache?: boolean;
+    shouldIgnoreCommit?: boolean;
+    shouldSendLegacyResponse?: boolean;
+    withoutSharing?: boolean;
+}

package/dist/es/es2018/types/src/generated/types/DataMapperExecutionOutputRepresentation.d.ts

@@ -0,0 +1,44 @@
+import { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 1000;
+export declare const VERSION = "7dcdd5520d488c4d87cf420c16231776";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    status: string;
+}
+export type DataMapperExecutionOutputRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialDataMapperExecutionOutputRepresentationNormalizedKeyMetadata = Partial<KeyParams> & $64$luvio_engine_NormalizedKeyMetadata;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: KeyParams): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: KeyParams): DataMapperExecutionOutputRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: DataMapperExecutionOutputRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: DataMapperExecutionOutputRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: DataMapperExecutionOutputRepresentation, existing: DataMapperExecutionOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DataMapperExecutionOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DataMapperExecutionOutputRepresentationNormalized, incoming: DataMapperExecutionOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DataMapperExecutionOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Data mapper execution Output Representation
+ *
+ * Keys:
+ *    status (string): status
+ */
+export interface DataMapperExecutionOutputRepresentationNormalized {
+    /** The response of execution as a JSON string */
+    error: string;
+    /** The response of execution as a JSON string */
+    response: Array<string>;
+    /** The response of execution as a JSON string */
+    status: string;
+}
+/**
+ * Data mapper execution Output Representation
+ *
+ * Keys:
+ *    status (string): status
+ */
+export interface DataMapperExecutionOutputRepresentation {
+    error: string;
+    response: Array<string>;
+    status: string;
+}

package/dist/es/es2018/types/src/generated/types/DataMapperListRepresentation.d.ts

@@ -0,0 +1,29 @@
+import { DataMapperParamRepresentation as DataMapperParamRepresentation_DataMapperParamRepresentation } from './DataMapperParamRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "fe384c995d3409df67e77f21a4154504";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DataMapperListRepresentation, existing: DataMapperListRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DataMapperListRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DataMapperListRepresentationNormalized, incoming: DataMapperListRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DataMapperListRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Datamappers List Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DataMapperListRepresentationNormalized {
+    /** The list of data raptors */
+    dataMappers: Array<DataMapperParamRepresentation_DataMapperParamRepresentation>;
+}
+/**
+ * Datamappers List Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DataMapperListRepresentation {
+    dataMappers: Array<DataMapperParamRepresentation_DataMapperParamRepresentation>;
+}

package/dist/es/es2018/types/src/generated/types/DataMapperParamRepresentation.d.ts

@@ -0,0 +1,31 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "8faa55d27f751062c3c96a0899d4e842";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DataMapperParamRepresentation, existing: DataMapperParamRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DataMapperParamRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DataMapperParamRepresentationNormalized, incoming: DataMapperParamRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DataMapperParamRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Datamapper param Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DataMapperParamRepresentationNormalized {
+    /** Data Raptor Name */
+    dataMapperName: string;
+    /** Input data for data raptor */
+    input?: string;
+}
+/**
+ * Datamapper param Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DataMapperParamRepresentation {
+    dataMapperName: string;
+    input?: string;
+}

package/dist/es/es2018/types/src/generated/types/DatamapperCacheInputParamRepresentation.d.ts

@@ -0,0 +1,32 @@
+import { DataMapperListRepresentation as DataMapperListRepresentation_DataMapperListRepresentation } from './DataMapperListRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "ccb2913c49bf30776dce2c094156e3b1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DatamapperCacheInputParamRepresentation, existing: DatamapperCacheInputParamRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DatamapperCacheInputParamRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DatamapperCacheInputParamRepresentationNormalized, incoming: DatamapperCacheInputParamRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DatamapperCacheInputParamRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Datamapper Cache Input Parameters Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DatamapperCacheInputParamRepresentationNormalized {
+    /** The cache storage type */
+    cacheStorageType: string;
+    /** The list of data mapper names */
+    dataMapperList: DataMapperListRepresentation_DataMapperListRepresentation;
+}
+/**
+ * Datamapper Cache Input Parameters Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DatamapperCacheInputParamRepresentation {
+    cacheStorageType: string;
+    dataMapperList: DataMapperListRepresentation_DataMapperListRepresentation;
+}

package/dist/es/es2018/types/src/generated/types/DatamapperClearCacheOutputRepresentation.d.ts

@@ -0,0 +1,45 @@
+import { DatamapperClearCacheResponse as DatamapperClearCacheResponse_DatamapperClearCacheResponse } from './DatamapperClearCacheResponse';
+import { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 1000;
+export declare const VERSION = "5de97f1862dd2fdeb34f5210a703e0dd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    status: boolean;
+}
+export type DatamapperClearCacheOutputRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialDatamapperClearCacheOutputRepresentationNormalizedKeyMetadata = Partial<KeyParams> & $64$luvio_engine_NormalizedKeyMetadata;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: KeyParams): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: KeyParams): DatamapperClearCacheOutputRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: DatamapperClearCacheOutputRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: DatamapperClearCacheOutputRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: DatamapperClearCacheOutputRepresentation, existing: DatamapperClearCacheOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DatamapperClearCacheOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DatamapperClearCacheOutputRepresentationNormalized, incoming: DatamapperClearCacheOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DatamapperClearCacheOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Response for clearing cache for list of inputs
+ *
+ * Keys:
+ *    status (boolean): status
+ */
+export interface DatamapperClearCacheOutputRepresentationNormalized {
+    /** A message describing the result of the cache clear operation */
+    error?: string;
+    /** List of response for the clear cache execution */
+    responseList?: Array<DatamapperClearCacheResponse_DatamapperClearCacheResponse>;
+    /** Indicates if the cache was cleared successfully or not */
+    status: boolean;
+}
+/**
+ * Response for clearing cache for list of inputs
+ *
+ * Keys:
+ *    status (boolean): status
+ */
+export interface DatamapperClearCacheOutputRepresentation {
+    error?: string;
+    responseList?: Array<DatamapperClearCacheResponse_DatamapperClearCacheResponse>;
+    status: boolean;
+}

package/dist/es/es2018/types/src/generated/types/DatamapperClearCacheResponse.d.ts

@@ -0,0 +1,31 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "a3d53e2d4e021c513f2bffc349a3ce64";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DatamapperClearCacheResponse, existing: DatamapperClearCacheResponseNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DatamapperClearCacheResponseNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DatamapperClearCacheResponseNormalized, incoming: DatamapperClearCacheResponseNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DatamapperClearCacheResponse, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Response for clearing cache
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DatamapperClearCacheResponseNormalized {
+    /** A message describing the result of the cache clear operation */
+    error?: string;
+    /** Indicates if the cache was cleared successfully or not */
+    status: boolean;
+}
+/**
+ * Response for clearing cache
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DatamapperClearCacheResponse {
+    error?: string;
+    status: boolean;
+}

package/dist/es/es2018/types/src/generated/types/DesignerCustomizationElementWarningOutputRepresentation.d.ts

@@ -0,0 +1,33 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const TTL = 10000;
+export declare const VERSION = "c7eab232844e3ba10a3ca9a8161b97b1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DesignerCustomizationElementWarningOutputRepresentation, existing: DesignerCustomizationElementWarningOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DesignerCustomizationElementWarningOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DesignerCustomizationElementWarningOutputRepresentationNormalized, incoming: DesignerCustomizationElementWarningOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DesignerCustomizationElementWarningOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output representation of designer customization element warning
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DesignerCustomizationElementWarningOutputRepresentationNormalized {
+    /** results */
+    results: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * Output representation of designer customization element warning
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DesignerCustomizationElementWarningOutputRepresentation {
+    results: {
+        [key: string]: unknown;
+    };
+}

package/dist/es/es2018/types/src/generated/types/DesignerCutomizationOutputRepresentation.d.ts

@@ -0,0 +1,33 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const TTL = 10000;
+export declare const VERSION = "ec8352aff02d43f00c4a4987c3652377";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DesignerCutomizationOutputRepresentation, existing: DesignerCutomizationOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DesignerCutomizationOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DesignerCutomizationOutputRepresentationNormalized, incoming: DesignerCutomizationOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DesignerCutomizationOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output representation of designer customization
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DesignerCutomizationOutputRepresentationNormalized {
+    /** results */
+    results: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * Output representation of designer customization
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DesignerCutomizationOutputRepresentation {
+    results: {
+        [key: string]: unknown;
+    };
+}

package/dist/es/es2018/types/src/generated/types/DocumentRepresentation.d.ts

@@ -0,0 +1,37 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "3ee906f386b97d816da5214dcf4ffe3b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DocumentRepresentation, existing: DocumentRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DocumentRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DocumentRepresentationNormalized, incoming: DocumentRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DocumentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output representation of moving an element in Omni-Script
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentRepresentationNormalized {
+    /** developerName */
+    developerName?: string | null;
+    /** id */
+    id?: string | null;
+    /** name */
+    name?: string | null;
+    /** type */
+    type?: string | null;
+}
+/**
+ * Output representation of moving an element in Omni-Script
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentRepresentation {
+    developerName?: string | null;
+    id?: string | null;
+    name?: string | null;
+    type?: string | null;
+}

package/dist/es/es2018/types/src/generated/types/DocusignTemplatesOutputRepresentation.d.ts

@@ -0,0 +1,32 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const TTL = 10000;
+export declare const VERSION = "49563791a6853b5e5f58c55eaa031d09";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DocusignTemplatesOutputRepresentation, existing: DocusignTemplatesOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DocusignTemplatesOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DocusignTemplatesOutputRepresentationNormalized, incoming: DocusignTemplatesOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DocusignTemplatesOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output representation of fetching Docusign templates
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocusignTemplatesOutputRepresentationNormalized {
+    /** message */
+    message: string;
+    /** statusCode */
+    statusCode: string;
+}
+/**
+ * Output representation of fetching Docusign templates
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocusignTemplatesOutputRepresentation {
+    message: string;
+    statusCode: string;
+}

package/dist/es/es2018/types/src/generated/types/DynamicElementsOutputRepresentation.d.ts

@@ -0,0 +1,33 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const TTL = 10000;
+export declare const VERSION = "ea2a0fe115fbb66ebbd972fbf2841d75";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DynamicElementsOutputRepresentation, existing: DynamicElementsOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DynamicElementsOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DynamicElementsOutputRepresentationNormalized, incoming: DynamicElementsOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DynamicElementsOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output representation of fetching dynamic elements
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DynamicElementsOutputRepresentationNormalized {
+    /** results */
+    results: Array<{
+        [key: string]: unknown;
+    }>;
+}
+/**
+ * Output representation of fetching dynamic elements
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DynamicElementsOutputRepresentation {
+    results: Array<{
+        [key: string]: unknown;
+    }>;
+}

package/dist/es/es2018/types/src/generated/types/IntegrationProcedureCacheInputData.d.ts

@@ -0,0 +1,34 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "8028202b290735ec11f8c5a4e3a28612";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: IntegrationProcedureCacheInputData, existing: IntegrationProcedureCacheInputDataNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): IntegrationProcedureCacheInputDataNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: IntegrationProcedureCacheInputDataNormalized, incoming: IntegrationProcedureCacheInputDataNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: IntegrationProcedureCacheInputData, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Integration Procedure Cache Input Data
+ *
+ * Keys:
+ *    (none)
+ */
+export interface IntegrationProcedureCacheInputDataNormalized {
+    /** String for providing the blockname for Integration Procedure */
+    blockName?: string;
+    /** JSON reprsentation of Input Data for Integration Procedure cache */
+    inputData?: string;
+    /** IP Key in <Type_SubType> format */
+    ipkey?: string;
+}
+/**
+ * Integration Procedure Cache Input Data
+ *
+ * Keys:
+ *    (none)
+ */
+export interface IntegrationProcedureCacheInputData {
+    blockName?: string;
+    inputData?: string;
+    ipkey?: string;
+}

package/dist/es/es2018/types/src/generated/types/IntegrationProcedureCacheInputDataRepresentationList.d.ts

@@ -0,0 +1,29 @@
+import { IntegrationProcedureCacheInputData as IntegrationProcedureCacheInputData_IntegrationProcedureCacheInputData } from './IntegrationProcedureCacheInputData';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "ad8eb8305070aa603d90fc09f34be708";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: IntegrationProcedureCacheInputDataRepresentationList, existing: IntegrationProcedureCacheInputDataRepresentationListNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): IntegrationProcedureCacheInputDataRepresentationListNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: IntegrationProcedureCacheInputDataRepresentationListNormalized, incoming: IntegrationProcedureCacheInputDataRepresentationListNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: IntegrationProcedureCacheInputDataRepresentationList, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Integration Procedure Cache Input Representation List
+ *
+ * Keys:
+ *    (none)
+ */
+export interface IntegrationProcedureCacheInputDataRepresentationListNormalized {
+    /** List of input data for Integration Procedure Cache */
+    inputs: Array<IntegrationProcedureCacheInputData_IntegrationProcedureCacheInputData>;
+}
+/**
+ * Integration Procedure Cache Input Representation List
+ *
+ * Keys:
+ *    (none)
+ */
+export interface IntegrationProcedureCacheInputDataRepresentationList {
+    inputs: Array<IntegrationProcedureCacheInputData_IntegrationProcedureCacheInputData>;
+}