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

package/dist/es/es2018/types/src/generated/adapters/adapter-utils.d.ts

@@ -0,0 +1,62 @@
+import { Adapter as $64$luvio_engine_Adapter, Snapshot as $64$luvio_engine_Snapshot, UnfulfilledSnapshot as $64$luvio_engine_UnfulfilledSnapshot, AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata } from '@luvio/engine';
+export declare const ObjectPrototypeHasOwnProperty: (v: PropertyKey) => boolean;
+declare const ObjectKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, ObjectCreate: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+};
+export { ObjectCreate, ObjectKeys };
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const ArrayPrototypePush: (...items: any[]) => number;
+export interface AdapterValidationConfig {
+    displayName: string;
+    parameters: {
+        required: string[];
+        optional: string[];
+        unsupported?: string[];
+    };
+}
+/**
+ * Validates an adapter config is well-formed.
+ * @param config The config to validate.
+ * @param adapter The adapter validation configuration.
+ * @param oneOf The keys the config must contain at least one of.
+ * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+ */
+export declare function validateConfig<T>(config: Untrusted<T>, adapter: AdapterValidationConfig, oneOf?: string[]): void;
+export declare function untrustedIsObject<Base>(untrusted: unknown): untrusted is Untrusted<Base>;
+export type UncoercedConfiguration<Base, Options extends {
+    [key in keyof Base]?: any;
+}> = {
+    [Key in keyof Base]?: Base[Key] | Options[Key];
+};
+export type Untrusted<Base> = Partial<Base>;
+export declare function areRequiredParametersPresent<T>(config: any, configPropertyNames: AdapterValidationConfig): config is T;
+export declare function refreshable<C, D, R>(adapter: $64$luvio_engine_Adapter<C, D>, resolve: (config: unknown) => Promise<$64$luvio_engine_Snapshot<R>>): $64$luvio_engine_Adapter<C, D>;
+export declare const SNAPSHOT_STATE_FULFILLED = "Fulfilled";
+export declare const SNAPSHOT_STATE_UNFULFILLED = "Unfulfilled";
+export declare const snapshotRefreshOptions: {
+    overrides: {
+        headers: {
+            'Cache-Control': string;
+        };
+    };
+};
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+export declare function stableJSONStringify(node: any): string | undefined;
+export declare function getFetchResponseStatusText(status: number): string;
+export declare function isUnfulfilledSnapshot<T, U>(snapshot: $64$luvio_engine_Snapshot<T, U>): snapshot is $64$luvio_engine_UnfulfilledSnapshot<T, U>;
+export declare function generateParamConfigMetadata(name: string, required: boolean, resourceType: $64$luvio_engine_AdapterConfigMetadata['resourceType'], typeCheckShape: $64$luvio_engine_AdapterConfigMetadata['typeCheckShape'], isArrayShape?: boolean, coerceFn?: (v: unknown) => unknown): $64$luvio_engine_AdapterConfigMetadata;
+export declare function buildAdapterValidationConfig(displayName: string, paramsMeta: $64$luvio_engine_AdapterConfigMetadata[]): AdapterValidationConfig;
+export declare const keyPrefix = "explainability";

package/dist/es/es2018/types/src/generated/adapters/getExplainabilityActionLogs.d.ts

@@ -0,0 +1,38 @@
+import { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Fragment as $64$luvio_engine_Fragment, Snapshot as $64$luvio_engine_Snapshot, FetchResponse as $64$luvio_engine_FetchResponse, ErrorResponse as $64$luvio_engine_ErrorResponse, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, CoercedAdapterRequestContext as $64$luvio_engine_CoercedAdapterRequestContext, StoreLookup as $64$luvio_engine_StoreLookup, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { Untrusted as adapter$45$utils_Untrusted, AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig } from './adapter-utils';
+import { ResourceRequestConfig as resources_getConnectDecisionExplainerActionLogs_ResourceRequestConfig } from '../resources/getConnectDecisionExplainerActionLogs';
+import { ExplainabilityActionLogsRepresentation as types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation } from '../types/ExplainabilityActionLogsRepresentation';
+export declare const adapterName = "getExplainabilityActionLogs";
+export declare const getExplainabilityActionLogs_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const getExplainabilityActionLogs_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface GetExplainabilityActionLogsConfig {
+    actionContextCode?: string;
+    applicationSubType?: string;
+    applicationType?: string;
+    createdAfter?: string;
+    createdBefore?: string;
+    pageSize?: number;
+    processType?: string;
+    queryMore?: string;
+    primaryFilter?: string;
+    secondaryFilter?: string;
+    additionalFilter?: string;
+    sortDirection?: string;
+}
+export declare const createResourceParams: (config: GetExplainabilityActionLogsConfig) => resources_getConnectDecisionExplainerActionLogs_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityActionLogsConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityActionLogsConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetExplainabilityActionLogsConfig>): adapter$45$utils_Untrusted<GetExplainabilityActionLogsConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetExplainabilityActionLogsConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityActionLogsConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityActionLogsConfig): $64$luvio_engine_Snapshot<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityActionLogsConfig, resourceParams: resources_getConnectDecisionExplainerActionLogs_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation>): Promise<import("@luvio/engine").FulfilledSnapshot<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation, any>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityActionLogsConfig, resourceParams: resources_getConnectDecisionExplainerActionLogs_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityActionLogsConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: GetExplainabilityActionLogsConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation>): $64$luvio_engine_Snapshot<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation, any>;
+export declare const getExplainabilityActionLogsAdapterFactory: $64$luvio_engine_AdapterFactory<GetExplainabilityActionLogsConfig, types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation>;

package/dist/es/es2018/types/src/generated/adapters/getExplainabilityDetailedActionLog.d.ts

@@ -0,0 +1,32 @@
+import { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Fragment as $64$luvio_engine_Fragment, Snapshot as $64$luvio_engine_Snapshot, FetchResponse as $64$luvio_engine_FetchResponse, ErrorResponse as $64$luvio_engine_ErrorResponse, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, CoercedAdapterRequestContext as $64$luvio_engine_CoercedAdapterRequestContext, StoreLookup as $64$luvio_engine_StoreLookup, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { Untrusted as adapter$45$utils_Untrusted, AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig } from './adapter-utils';
+import { ResourceRequestConfig as resources_getConnectDecisionExplainerDetailedActionLog_ResourceRequestConfig } from '../resources/getConnectDecisionExplainerDetailedActionLog';
+import { ExplainabilityDetailedActionLogDetailRepresentation as types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation } from '../types/ExplainabilityDetailedActionLogDetailRepresentation';
+export declare const adapterName = "getExplainabilityDetailedActionLog";
+export declare const getExplainabilityDetailedActionLog_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const getExplainabilityDetailedActionLog_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface GetExplainabilityDetailedActionLogConfig {
+    actionContextCode: string;
+    applicationSubType: string;
+    applicationType: string;
+    actionLogDateTime: string;
+    processType: string;
+    uniqueIdentifier: string;
+}
+export declare const createResourceParams: (config: GetExplainabilityDetailedActionLogConfig) => resources_getConnectDecisionExplainerDetailedActionLog_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityDetailedActionLogConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityDetailedActionLogConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetExplainabilityDetailedActionLogConfig>): adapter$45$utils_Untrusted<GetExplainabilityDetailedActionLogConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetExplainabilityDetailedActionLogConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityDetailedActionLogConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityDetailedActionLogConfig): $64$luvio_engine_Snapshot<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityDetailedActionLogConfig, resourceParams: resources_getConnectDecisionExplainerDetailedActionLog_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation>): Promise<import("@luvio/engine").FulfilledSnapshot<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation, any>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityDetailedActionLogConfig, resourceParams: resources_getConnectDecisionExplainerDetailedActionLog_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetExplainabilityDetailedActionLogConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: GetExplainabilityDetailedActionLogConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation>): $64$luvio_engine_Snapshot<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation, any>;
+export declare const getExplainabilityDetailedActionLogAdapterFactory: $64$luvio_engine_AdapterFactory<GetExplainabilityDetailedActionLogConfig, types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation>;

package/dist/es/es2018/types/src/generated/adapters/storeExplainabilityActionLog.d.ts

@@ -0,0 +1,16 @@
+import { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { Untrusted as adapter$45$utils_Untrusted, AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig } from './adapter-utils';
+import { ExplainabilityActionLogInputRepresentation as types_ExplainabilityActionLogInputRepresentation_ExplainabilityActionLogInputRepresentation } from '../types/ExplainabilityActionLogInputRepresentation';
+import { ResourceRequestConfig as resources_postConnectDecisionExplainerActionLogs_ResourceRequestConfig } from '../resources/postConnectDecisionExplainerActionLogs';
+import { ExplainabilityActionLogCreateRepresentation as types_ExplainabilityActionLogCreateRepresentation_ExplainabilityActionLogCreateRepresentation } from '../types/ExplainabilityActionLogCreateRepresentation';
+export declare const adapterName = "storeExplainabilityActionLog";
+export declare const storeExplainabilityActionLog_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const storeExplainabilityActionLog_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface StoreExplainabilityActionLogConfig {
+    explainabilityActionLogDefinition: types_ExplainabilityActionLogInputRepresentation_ExplainabilityActionLogInputRepresentation;
+}
+export declare const createResourceParams: (config: StoreExplainabilityActionLogConfig) => resources_postConnectDecisionExplainerActionLogs_ResourceRequestConfig;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<StoreExplainabilityActionLogConfig>): adapter$45$utils_Untrusted<StoreExplainabilityActionLogConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): StoreExplainabilityActionLogConfig | null;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: StoreExplainabilityActionLogConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<import("@luvio/engine").FulfilledSnapshot<types_ExplainabilityActionLogCreateRepresentation_ExplainabilityActionLogCreateRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_ExplainabilityActionLogCreateRepresentation_ExplainabilityActionLogCreateRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_ExplainabilityActionLogCreateRepresentation_ExplainabilityActionLogCreateRepresentation, any>>;
+export declare const storeExplainabilityActionLogAdapterFactory: $64$luvio_engine_AdapterFactory<StoreExplainabilityActionLogConfig, types_ExplainabilityActionLogCreateRepresentation_ExplainabilityActionLogCreateRepresentation>;

package/dist/es/es2018/types/src/generated/artifacts/main.d.ts

@@ -0,0 +1,3 @@
+export { getExplainabilityActionLogsAdapterFactory } from '../adapters/getExplainabilityActionLogs';
+export { storeExplainabilityActionLogAdapterFactory } from '../adapters/storeExplainabilityActionLog';
+export { getExplainabilityDetailedActionLogAdapterFactory } from '../adapters/getExplainabilityDetailedActionLog';

package/dist/es/es2018/types/src/generated/artifacts/sfdc.d.ts

@@ -0,0 +1,6 @@
+declare let getExplainabilityActionLogs: any;
+declare let getExplainabilityDetailedActionLog: any;
+declare let storeExplainabilityActionLog: any;
+declare let getExplainabilityActionLogs_imperative: any;
+declare let getExplainabilityDetailedActionLog_imperative: any;
+export { getExplainabilityActionLogs, getExplainabilityDetailedActionLog, storeExplainabilityActionLog, getExplainabilityActionLogs_imperative, getExplainabilityDetailedActionLog_imperative, };

package/dist/es/es2018/types/src/generated/resources/getConnectDecisionExplainerActionLogs.d.ts

@@ -0,0 +1,26 @@
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, FetchResponse as $64$luvio_engine_FetchResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ErrorResponse as $64$luvio_engine_ErrorResponse, ErrorSnapshot as $64$luvio_engine_ErrorSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { ExplainabilityActionLogsRepresentation as types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation } from '../types/ExplainabilityActionLogsRepresentation';
+export interface ResourceRequestConfig {
+    queryParams: {
+        actionContextCode?: string;
+        applicationSubType?: string;
+        applicationType?: string;
+        createdAfter?: string;
+        createdBefore?: string;
+        pageSize?: number;
+        processType?: string;
+        queryMore?: string;
+        primaryFilter?: string;
+        secondaryFilter?: string;
+        additionalFilter?: string;
+        sortDirection?: string;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function getResponseCacheKeys(storeKeyMap: any, luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation, any>;
+export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_ExplainabilityActionLogsRepresentation_ExplainabilityActionLogsRepresentation>): $64$luvio_engine_ErrorSnapshot;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

package/dist/es/es2018/types/src/generated/resources/getConnectDecisionExplainerDetailedActionLog.d.ts

@@ -0,0 +1,20 @@
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, FetchResponse as $64$luvio_engine_FetchResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ErrorResponse as $64$luvio_engine_ErrorResponse, ErrorSnapshot as $64$luvio_engine_ErrorSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { ExplainabilityDetailedActionLogDetailRepresentation as types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation } from '../types/ExplainabilityDetailedActionLogDetailRepresentation';
+export interface ResourceRequestConfig {
+    queryParams: {
+        actionContextCode: string;
+        applicationSubType: string;
+        applicationType: string;
+        actionLogDateTime: string;
+        processType: string;
+        uniqueIdentifier: string;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function getResponseCacheKeys(storeKeyMap: any, luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation, any>;
+export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_ExplainabilityDetailedActionLogDetailRepresentation_ExplainabilityDetailedActionLogDetailRepresentation>): $64$luvio_engine_ErrorSnapshot;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

package/dist/es/es2018/types/src/generated/resources/postConnectDecisionExplainerActionLogs.d.ts

@@ -0,0 +1,13 @@
+import { ExplainabilityActionLogInputRepresentation as types_ExplainabilityActionLogInputRepresentation_ExplainabilityActionLogInputRepresentation } from '../types/ExplainabilityActionLogInputRepresentation';
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, FetchResponse as $64$luvio_engine_FetchResponse, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { ExplainabilityActionLogCreateRepresentation as types_ExplainabilityActionLogCreateRepresentation_ExplainabilityActionLogCreateRepresentation } from '../types/ExplainabilityActionLogCreateRepresentation';
+export interface ResourceRequestConfig {
+    body: {
+        explainabilityActionLogDefinition: types_ExplainabilityActionLogInputRepresentation_ExplainabilityActionLogInputRepresentation;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function getResponseCacheKeys(storeKeyMap: any, luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_ExplainabilityActionLogCreateRepresentation_ExplainabilityActionLogCreateRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_ExplainabilityActionLogCreateRepresentation_ExplainabilityActionLogCreateRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_ExplainabilityActionLogCreateRepresentation_ExplainabilityActionLogCreateRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_ExplainabilityActionLogCreateRepresentation_ExplainabilityActionLogCreateRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_ExplainabilityActionLogCreateRepresentation_ExplainabilityActionLogCreateRepresentation, any>;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

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

@@ -0,0 +1,41 @@
+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, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 10000;
+export declare const VERSION = "0d45c6e4f0bafbddf9b0c6a50f5e1a25";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    id: string;
+}
+export type ExplainabilityActionLogCreateRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialExplainabilityActionLogCreateRepresentationNormalizedKeyMetadata = 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): ExplainabilityActionLogCreateRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ExplainabilityActionLogCreateRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ExplainabilityActionLogCreateRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ExplainabilityActionLogCreateRepresentation, existing: ExplainabilityActionLogCreateRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ExplainabilityActionLogCreateRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ExplainabilityActionLogCreateRepresentationNormalized, incoming: ExplainabilityActionLogCreateRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ExplainabilityActionLogCreateRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Create represenation for ExplainabilityActionLog
+ *
+ * Keys:
+ *    id (string): uniqueIdentifier
+ */
+export interface ExplainabilityActionLogCreateRepresentationNormalized {
+    /** SequenceNumber of ExplainabilityActionLog */
+    sequenceNumber?: number;
+    /** uniqueIdentifier of ExplainabilityActionLog */
+    uniqueIdentifier: string;
+}
+/**
+ * Create represenation for ExplainabilityActionLog
+ *
+ * Keys:
+ *    id (string): uniqueIdentifier
+ */
+export interface ExplainabilityActionLogCreateRepresentation {
+    sequenceNumber?: number;
+    uniqueIdentifier: string;
+}

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

@@ -0,0 +1,67 @@
+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 = "676f634d55d88c3557a45090cc1413bb";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ExplainabilityActionLogDetailRepresentation, existing: ExplainabilityActionLogDetailRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ExplainabilityActionLogDetailRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ExplainabilityActionLogDetailRepresentationNormalized, incoming: ExplainabilityActionLogDetailRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ExplainabilityActionLogDetailRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents a Explainability Action Log details
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExplainabilityActionLogDetailRepresentationNormalized {
+    /** The record ID within the context of the associated application's action that can be used to retrieve the action log */
+    actionContextCode: string;
+    /** The contents of the Explainability action log as a Json string */
+    actionLog?: string;
+    /** A string to be used as additional filter */
+    additionalFilter?: string;
+    /** The Calendar date and time at which the Explainability log was generated by the application's action */
+    applicationLogCalendarDate: string;
+    /** The date and time at which the Explainability action log was generated by the application's action */
+    applicationLogDate: string;
+    /** Specifies the subtype of the associated application for which the explainability log is generated. This would match one of the valid values for Explainability Action Specification table's ApplicationSubtype field */
+    applicationSubtype: string;
+    /** Specifies the name of the application for which the explainability service is run. This would match one of the valid values for Explainability Action Specification table's ApplicationType field */
+    applicationType: string;
+    /** A name to identify the Explainability specification name of the action log record */
+    explainabilitySpecName: string;
+    /** Indicates whether the action Log is chunked (true) or not (false). The default value is false. */
+    isChunked: boolean;
+    /** A name to identify the Explainability action log record to be created */
+    name: string;
+    /** A string to be used as primary filter */
+    primaryFilter?: string;
+    /** Specifies the process type, such as the business process, of the associated application for which the explainability action log is generated. This would match one of the valid values for Explainability Action Specification table's processType field */
+    processType: string;
+    /** A string to be used as secondary filter */
+    secondaryFilter?: string;
+    /** A string to be used as explainability unique identifier */
+    uniqueIdentifier: string;
+}
+/**
+ * Represents a Explainability Action Log details
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExplainabilityActionLogDetailRepresentation {
+    actionContextCode: string;
+    actionLog?: string;
+    additionalFilter?: string;
+    applicationLogCalendarDate: string;
+    applicationLogDate: string;
+    applicationSubtype: string;
+    applicationType: string;
+    explainabilitySpecName: string;
+    isChunked: boolean;
+    name: string;
+    primaryFilter?: string;
+    processType: string;
+    secondaryFilter?: string;
+    uniqueIdentifier: string;
+}

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

@@ -0,0 +1,52 @@
+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 = "99d788a91e815cc9be3484b4355ac623";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ExplainabilityActionLogInputRepresentation, existing: ExplainabilityActionLogInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ExplainabilityActionLogInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ExplainabilityActionLogInputRepresentationNormalized, incoming: ExplainabilityActionLogInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ExplainabilityActionLogInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for ExplainabilityActionLog
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExplainabilityActionLogInputRepresentationNormalized {
+    /** A valid Salesforce record-id that can later be used to retrieve the Explainability action log record */
+    actionContextCode: string;
+    /** The contents of the Explainability action log as a Json string */
+    actionLog: string;
+    /** The date and time at which the Explainability action log was generated by the application’s action */
+    actionLogDate: string;
+    /** The 18 character Salesforce user id of the user who will own the action log. If not specified, will default to the user in whose context the call is being made. */
+    actionLogOwnerId?: string;
+    /** A string to be used as additional filter */
+    additionalFilter?: string;
+    /** A name to identify the Explainability action log record to be created */
+    name?: string;
+    /** A string to be used as primary filter */
+    primaryFilter?: string;
+    /** A string to be used as secondary filter */
+    secondaryFilter?: string;
+    /** A name that uniquely identifies an active Explainability Action Specification record */
+    specificationName: string;
+}
+/**
+ * Input representation for ExplainabilityActionLog
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExplainabilityActionLogInputRepresentation {
+    actionContextCode: string;
+    actionLog: string;
+    actionLogDate: string;
+    actionLogOwnerId?: string;
+    additionalFilter?: string;
+    name?: string;
+    primaryFilter?: string;
+    secondaryFilter?: string;
+    specificationName: string;
+}

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

@@ -0,0 +1,28 @@
+import { ExplainabilityActionLogInputRepresentation as ExplainabilityActionLogInputRepresentation_ExplainabilityActionLogInputRepresentation } from './ExplainabilityActionLogInputRepresentation';
+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 = "47cf3645263acbfa2cceb8fbfc19b6b1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ExplainabilityActionLogInputRepresentationWrapper, existing: ExplainabilityActionLogInputRepresentationWrapperNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ExplainabilityActionLogInputRepresentationWrapperNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ExplainabilityActionLogInputRepresentationWrapperNormalized, incoming: ExplainabilityActionLogInputRepresentationWrapperNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ExplainabilityActionLogInputRepresentationWrapper, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Wrapper Input Representation for ExplainabilityActionLogInputRepresentation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExplainabilityActionLogInputRepresentationWrapperNormalized {
+    explainabilityActionLogDefinition: ExplainabilityActionLogInputRepresentation_ExplainabilityActionLogInputRepresentation;
+}
+/**
+ * Wrapper Input Representation for ExplainabilityActionLogInputRepresentation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExplainabilityActionLogInputRepresentationWrapper {
+    explainabilityActionLogDefinition: ExplainabilityActionLogInputRepresentation_ExplainabilityActionLogInputRepresentation;
+}

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

@@ -0,0 +1,33 @@
+import { ExplainabilityActionLogDetailRepresentation as ExplainabilityActionLogDetailRepresentation_ExplainabilityActionLogDetailRepresentation } from './ExplainabilityActionLogDetailRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, 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 = "d0452c2b6e53e2a843a03bf30a275e18";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ExplainabilityActionLogsRepresentation, existing: ExplainabilityActionLogsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ExplainabilityActionLogsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ExplainabilityActionLogsRepresentationNormalized, incoming: ExplainabilityActionLogsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ExplainabilityActionLogsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of the list of Explainability Action Logs
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExplainabilityActionLogsRepresentationNormalized {
+    /** A list of ExplainabilityActionLogRepresentation */
+    actionLogs: Array<ExplainabilityActionLogDetailRepresentation_ExplainabilityActionLogDetailRepresentation>;
+    /** A string that can be passed to the next call to fetch the next batch of Explainability Action Log records */
+    queryMore?: string;
+}
+/**
+ * Representation of the list of Explainability Action Logs
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExplainabilityActionLogsRepresentation {
+    actionLogs: Array<ExplainabilityActionLogDetailRepresentation_ExplainabilityActionLogDetailRepresentation>;
+    queryMore?: string;
+}

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

@@ -0,0 +1,62 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, 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 = "2ead56c771f0c2cc2857826a85e490c8";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ExplainabilityDetailedActionLogDetailRepresentation, existing: ExplainabilityDetailedActionLogDetailRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ExplainabilityDetailedActionLogDetailRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ExplainabilityDetailedActionLogDetailRepresentationNormalized, incoming: ExplainabilityDetailedActionLogDetailRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ExplainabilityDetailedActionLogDetailRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents a Explainability Action Log details
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExplainabilityDetailedActionLogDetailRepresentationNormalized {
+    /** The record ID within the context of the associated application's action that can be used to retrieve the action log */
+    actionContextCode: string;
+    /** The contents of the Explainability action log as a Json string */
+    actionLog: string;
+    /** A string to be used as additional filter */
+    additionalFilter?: string;
+    /** The date and time at which the Explainability action log was generated by the application's action */
+    applicationLogDate: string;
+    /** Specifies the subtype of the associated application for which the explainability log is generated. This would match one of the valid values for Explainability Action Specification table's ApplicationSubtype field */
+    applicationSubtype: string;
+    /** Specifies the name of the application for which the explainability service is run. This would match one of the valid values for Explainability Action Specification table's ApplicationType field */
+    applicationType: string;
+    /** A name to identify the Explainability specification name of the action log record */
+    explainabilitySpecName: string;
+    /** A name to identify the Explainability action log record to be created */
+    name: string;
+    /** A string to be used as primary filter */
+    primaryFilter?: string;
+    /** Specifies the process type, such as the business process, of the associated application for which the explainability action log is generated. This would match one of the valid values for Explainability Action Specification table's processType field */
+    processType: string;
+    /** A string to be used as secondary filter */
+    secondaryFilter?: string;
+    /** A string to be used as explainability unique identifier */
+    uniqueIdentifier: string;
+}
+/**
+ * Represents a Explainability Action Log details
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExplainabilityDetailedActionLogDetailRepresentation {
+    actionContextCode: string;
+    actionLog: string;
+    additionalFilter?: string;
+    applicationLogDate: string;
+    applicationSubtype: string;
+    applicationType: string;
+    explainabilitySpecName: string;
+    name: string;
+    primaryFilter?: string;
+    processType: string;
+    secondaryFilter?: string;
+    uniqueIdentifier: string;
+}

package/dist/es/es2018/types/src/generated/types/type-utils.d.ts

@@ -0,0 +1,32 @@
+import { NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const ObjectKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, ObjectCreate: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, ObjectAssign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+};
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const JSONStringify: {
+    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+};
+type AllowedPrimitives = boolean | string | number | Date | null;
+type Value<T> = T extends AllowedPrimitives ? T : RecursivePartial<T>;
+export type RecursivePartial<T> = null | {
+    [P in keyof T]?: T[P] extends Array<infer U> ? Array<Value<U>> | null : Value<T[P]> | null;
+};
+export declare function equalsArray<U, V extends U[]>(a: V, b: V, equalsItem: (itemA: U, itemB: U) => boolean | void): boolean;
+export declare function equalsObject<U, V extends {
+    [key: string]: U;
+}>(a: V, b: V, equalsProp: (propA: U, propB: U) => boolean | void): boolean;
+export declare function createLink(ref: string | $64$luvio_engine_NormalizedKeyMetadata): {
+    __ref: string;
+};
+export declare function assignMetadataLink(entry: any, metadataKey: string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export {};