@salesforce/lds-adapters-service-ecm 1.389.2 → 1.390.0

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

@@ -1,5 +1,6 @@
 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 { TemplateDependencyConfiguration as types_TemplateDependencyConfiguration_TemplateDependencyConfiguration } from '../types/TemplateDependencyConfiguration';
 import { ResourceRequestConfig as resources_postConnectServiceAutomationTemplateDeployByTemplateId_ResourceRequestConfig } from '../resources/postConnectServiceAutomationTemplateDeployByTemplateId';
 import { DeploymentOutputRepresentation as types_DeploymentOutputRepresentation_DeploymentOutputRepresentation } from '../types/DeploymentOutputRepresentation';
 export declare const adapterName = "deployTemplate";
@@ -7,6 +8,7 @@ export declare const deployTemplate_ConfigPropertyMetadata: $64$luvio_engine_Ada
 export declare const deployTemplate_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
 export interface DeployTemplateConfig {
     templateId: string;
+    flowTemplates: Array<types_TemplateDependencyConfiguration_TemplateDependencyConfiguration>;
 }
 export declare const createResourceParams: (config: DeployTemplateConfig) => resources_postConnectServiceAutomationTemplateDeployByTemplateId_ResourceRequestConfig;
 export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<DeployTemplateConfig>): adapter$45$utils_Untrusted<DeployTemplateConfig>;

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

@@ -0,0 +1,30 @@
+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_getConnectServiceAutomationEligibilityRuleMetadata_ResourceRequestConfig } from '../resources/getConnectServiceAutomationEligibilityRuleMetadata';
+import { EligibilityRuleMetadataRepresentation as types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation } from '../types/EligibilityRuleMetadataRepresentation';
+export declare const adapterName = "getEligibilityRuleMetadata";
+export declare const getEligibilityRuleMetadata_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const getEligibilityRuleMetadata_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface GetEligibilityRuleMetadataConfig {
+    targetType?: string;
+    expressionSetId?: string;
+    eligibilityRuleType?: string;
+    decisionTableId?: string;
+}
+export declare const createResourceParams: (config: GetEligibilityRuleMetadataConfig) => resources_getConnectServiceAutomationEligibilityRuleMetadata_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetEligibilityRuleMetadataConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: GetEligibilityRuleMetadataConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetEligibilityRuleMetadataConfig>): adapter$45$utils_Untrusted<GetEligibilityRuleMetadataConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetEligibilityRuleMetadataConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: GetEligibilityRuleMetadataConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: GetEligibilityRuleMetadataConfig): $64$luvio_engine_Snapshot<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: GetEligibilityRuleMetadataConfig, resourceParams: resources_getConnectServiceAutomationEligibilityRuleMetadata_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation>): Promise<import("@luvio/engine").FulfilledSnapshot<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation, any>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: GetEligibilityRuleMetadataConfig, resourceParams: resources_getConnectServiceAutomationEligibilityRuleMetadata_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetEligibilityRuleMetadataConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: GetEligibilityRuleMetadataConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation>): $64$luvio_engine_Snapshot<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation, any>;
+export declare const getEligibilityRuleMetadataAdapterFactory: $64$luvio_engine_AdapterFactory<GetEligibilityRuleMetadataConfig, types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation>;

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

@@ -0,0 +1,21 @@
+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 { EligibilityRuleValueInputRepresentation as types_EligibilityRuleValueInputRepresentation_EligibilityRuleValueInputRepresentation } from '../types/EligibilityRuleValueInputRepresentation';
+import { ResourceRequestConfig as resources_postConnectServiceAutomationEligibilityRule_ResourceRequestConfig } from '../resources/postConnectServiceAutomationEligibilityRule';
+import { RuleOutputRepresentation as types_RuleOutputRepresentation_RuleOutputRepresentation } from '../types/RuleOutputRepresentation';
+export declare const adapterName = "saveEligibilityRule";
+export declare const saveEligibilityRule_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const saveEligibilityRule_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface SaveEligibilityRuleConfig {
+    conditionCriteria: string;
+    conditionType: string;
+    decisionTableId: string;
+    sourceObjectName: string;
+    sourceObjectRecordId: string;
+    ruleValue?: Array<types_EligibilityRuleValueInputRepresentation_EligibilityRuleValueInputRepresentation>;
+}
+export declare const createResourceParams: (config: SaveEligibilityRuleConfig) => resources_postConnectServiceAutomationEligibilityRule_ResourceRequestConfig;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<SaveEligibilityRuleConfig>): adapter$45$utils_Untrusted<SaveEligibilityRuleConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): SaveEligibilityRuleConfig | null;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: SaveEligibilityRuleConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<import("@luvio/engine").FulfilledSnapshot<types_RuleOutputRepresentation_RuleOutputRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_RuleOutputRepresentation_RuleOutputRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_RuleOutputRepresentation_RuleOutputRepresentation, any>>;
+export declare const saveEligibilityRuleAdapterFactory: $64$luvio_engine_AdapterFactory<SaveEligibilityRuleConfig, types_RuleOutputRepresentation_RuleOutputRepresentation>;

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

@@ -12,3 +12,5 @@ export { generateIntakeFormAdapterFactory } from '../adapters/generateIntakeForm
 export { generateOmniScriptAdapterFactory } from '../adapters/generateOmniScript';
 export { getServiceRequestAdapterFactory } from '../adapters/getServiceRequest';
 export { deployTemplateAdapterFactory } from '../adapters/deployTemplate';
+export { saveEligibilityRuleAdapterFactory } from '../adapters/saveEligibilityRule';
+export { getEligibilityRuleMetadataAdapterFactory } from '../adapters/getEligibilityRuleMetadata';

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

@@ -9,7 +9,9 @@ declare let getAgentActions: any;
 declare let getAllServiceAutomationDep: any;
 declare let getAllServiceProcessTemplate: any;
 declare let getCatalogItem: any;
+declare let getEligibilityRuleMetadata: any;
 declare let getServiceRequest: any;
+declare let saveEligibilityRule: any;
 declare let updateCatalogItem: any;
 declare let updateEpcCategories: any;
 declare let downloadServiceProcessTemplate_imperative: any;
@@ -17,5 +19,6 @@ declare let getAgentActions_imperative: any;
 declare let getAllServiceAutomationDep_imperative: any;
 declare let getAllServiceProcessTemplate_imperative: any;
 declare let getCatalogItem_imperative: any;
+declare let getEligibilityRuleMetadata_imperative: any;
 declare let getServiceRequest_imperative: any;
-export { createAgentAction, createAgentFlow, createCatalogItem, deployTemplate, downloadServiceProcessTemplate, generateIntakeForm, generateOmniScript, getAgentActions, getAllServiceAutomationDep, getAllServiceProcessTemplate, getCatalogItem, getServiceRequest, updateCatalogItem, updateEpcCategories, downloadServiceProcessTemplate_imperative, getAgentActions_imperative, getAllServiceAutomationDep_imperative, getAllServiceProcessTemplate_imperative, getCatalogItem_imperative, getServiceRequest_imperative, };
+export { createAgentAction, createAgentFlow, createCatalogItem, deployTemplate, downloadServiceProcessTemplate, generateIntakeForm, generateOmniScript, getAgentActions, getAllServiceAutomationDep, getAllServiceProcessTemplate, getCatalogItem, getEligibilityRuleMetadata, getServiceRequest, saveEligibilityRule, updateCatalogItem, updateEpcCategories, downloadServiceProcessTemplate_imperative, getAgentActions_imperative, getAllServiceAutomationDep_imperative, getAllServiceProcessTemplate_imperative, getCatalogItem_imperative, getEligibilityRuleMetadata_imperative, getServiceRequest_imperative, };

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

@@ -0,0 +1,18 @@
+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 { EligibilityRuleMetadataRepresentation as types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation } from '../types/EligibilityRuleMetadataRepresentation';
+export interface ResourceRequestConfig {
+    queryParams: {
+        targetType?: string;
+        expressionSetId?: string;
+        eligibilityRuleType?: string;
+        decisionTableId?: 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_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation, any>;
+export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_EligibilityRuleMetadataRepresentation_EligibilityRuleMetadataRepresentation>): $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/postConnectServiceAutomationEligibilityRule.d.ts

@@ -0,0 +1,18 @@
+import { EligibilityRuleValueInputRepresentation as types_EligibilityRuleValueInputRepresentation_EligibilityRuleValueInputRepresentation } from '../types/EligibilityRuleValueInputRepresentation';
+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 { RuleOutputRepresentation as types_RuleOutputRepresentation_RuleOutputRepresentation } from '../types/RuleOutputRepresentation';
+export interface ResourceRequestConfig {
+    body: {
+        conditionCriteria: string;
+        conditionType: string;
+        decisionTableId: string;
+        sourceObjectName: string;
+        sourceObjectRecordId: string;
+        ruleValue?: Array<types_EligibilityRuleValueInputRepresentation_EligibilityRuleValueInputRepresentation>;
+    };
+}
+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_RuleOutputRepresentation_RuleOutputRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_RuleOutputRepresentation_RuleOutputRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_RuleOutputRepresentation_RuleOutputRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_RuleOutputRepresentation_RuleOutputRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_RuleOutputRepresentation_RuleOutputRepresentation, any>;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

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

@@ -1,9 +1,13 @@
+import { TemplateDependencyConfiguration as types_TemplateDependencyConfiguration_TemplateDependencyConfiguration } from '../types/TemplateDependencyConfiguration';
 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 { DeploymentOutputRepresentation as types_DeploymentOutputRepresentation_DeploymentOutputRepresentation } from '../types/DeploymentOutputRepresentation';
 export interface ResourceRequestConfig {
     urlParams: {
         templateId: string;
     };
+    body: {
+        flowTemplates: Array<types_TemplateDependencyConfiguration_TemplateDependencyConfiguration>;
+    };
 }
 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_DeploymentOutputRepresentation_DeploymentOutputRepresentation): void;

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

@@ -0,0 +1,64 @@
+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 = "8da8a9539ab11c385bafdc5028d51ad1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DecisionTableParameterOutputRepresentation, existing: DecisionTableParameterOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DecisionTableParameterOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DecisionTableParameterOutputRepresentationNormalized, incoming: DecisionTableParameterOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DecisionTableParameterOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents the decision table parameter
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DecisionTableParameterOutputRepresentationNormalized {
+    /** Specifies the source object path for the mapping to the column of an entity */
+    columnMapping?: string;
+    /** Data Type of the field used */
+    dataType?: string;
+    /** Precision of the field used */
+    decimalScale?: number;
+    /** Specifies the entity domain field is mapped to */
+    domainEntity?: string;
+    /** The name of the field to be used in the decision table */
+    fieldName?: string;
+    /** Indicates whether the field is used to group the business rules of the decision table */
+    isGroupByField?: boolean;
+    /** Whether it is priority field or not */
+    isPriority?: boolean;
+    /** Valid operators for a field based on its usage */
+    isRequired?: boolean;
+    /** Maximum length of the field used */
+    maxlength?: number;
+    /** Indicates whether the field is mandatory to be provided during lookup for hashing column data */
+    operator?: string;
+    /** The sequence in which input fields are processed. */
+    sequence?: number;
+    /** Specifies the type of sorting done on the rows of a decision table */
+    sortType?: string;
+    /** A picklist to select whether a particular field will be used as input or output */
+    usage?: string;
+}
+/**
+ * Represents the decision table parameter
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DecisionTableParameterOutputRepresentation {
+    columnMapping?: string;
+    dataType?: string;
+    decimalScale?: number;
+    domainEntity?: string;
+    fieldName?: string;
+    isGroupByField?: boolean;
+    isPriority?: boolean;
+    isRequired?: boolean;
+    maxlength?: number;
+    operator?: string;
+    sequence?: number;
+    sortType?: string;
+    usage?: string;
+}

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

@@ -0,0 +1,40 @@
+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 = "f1589135819c1113935481d08bb2ddac";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DecisionTableSourceCriteriaOutputRepresentation, existing: DecisionTableSourceCriteriaOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DecisionTableSourceCriteriaOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DecisionTableSourceCriteriaOutputRepresentationNormalized, incoming: DecisionTableSourceCriteriaOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: DecisionTableSourceCriteriaOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents the decision table source criteria
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DecisionTableSourceCriteriaOutputRepresentationNormalized {
+    /** Specifies the operator used in the filter criteria */
+    operator?: string;
+    /** The sequence number of the filter criteria in the associated decision table source condition */
+    sequenceNumber?: number;
+    /** The name of the field that's used in the filter criteria */
+    sourceFieldName?: string;
+    /** The expected value of the field */
+    value?: string;
+    /** Specifies the type of filter value */
+    valueType?: string;
+}
+/**
+ * Represents the decision table source criteria
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DecisionTableSourceCriteriaOutputRepresentation {
+    operator?: string;
+    sequenceNumber?: number;
+    sourceFieldName?: string;
+    value?: string;
+    valueType?: string;
+}

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

@@ -0,0 +1,63 @@
+import { DecisionTableParameterOutputRepresentation as DecisionTableParameterOutputRepresentation_DecisionTableParameterOutputRepresentation } from './DecisionTableParameterOutputRepresentation';
+import { DecisionTableSourceCriteriaOutputRepresentation as DecisionTableSourceCriteriaOutputRepresentation_DecisionTableSourceCriteriaOutputRepresentation } from './DecisionTableSourceCriteriaOutputRepresentation';
+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 = "53a2c9a83f2af963d29b270a557a29ab";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EligibilityRuleDetailsRepresentation, existing: EligibilityRuleDetailsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EligibilityRuleDetailsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EligibilityRuleDetailsRepresentationNormalized, incoming: EligibilityRuleDetailsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EligibilityRuleDetailsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation for Decision Table Details.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EligibilityRuleDetailsRepresentationNormalized {
+    /** Indicates if criteria is enabled at the cell level (true) or not (false) */
+    cellLevelCriteriaEnabled: boolean;
+    /** The criteria for the condition */
+    conditionCriteria: string;
+    /** The type of the condition */
+    conditionType: string;
+    /** The unique identifier of the decision table that's associated with the eligibility rule */
+    decisionTableId: string;
+    /** The name of the decision table */
+    decisionTableName: string;
+    /** The description of the condition */
+    description: string;
+    /** The description of the for the decision table parameters */
+    parameters: Array<DecisionTableParameterOutputRepresentation_DecisionTableParameterOutputRepresentation>;
+    /** The criteria used to filter and select a specific type rule for application */
+    sourceCriteria: Array<DecisionTableSourceCriteriaOutputRepresentation_DecisionTableSourceCriteriaOutputRepresentation>;
+    /** Specifies the Source object used to get the necessary information */
+    sourceObject: string;
+    /** Specifies the format of the data source that the decision table uses */
+    sourceType: string;
+    /** The status of the process */
+    status: string;
+    /** The usage type of the decision table to evaluate the criteria */
+    usageType: string;
+}
+/**
+ * Representation for Decision Table Details.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EligibilityRuleDetailsRepresentation {
+    cellLevelCriteriaEnabled: boolean;
+    conditionCriteria: string;
+    conditionType: string;
+    decisionTableId: string;
+    decisionTableName: string;
+    description: string;
+    parameters: Array<DecisionTableParameterOutputRepresentation_DecisionTableParameterOutputRepresentation>;
+    sourceCriteria: Array<DecisionTableSourceCriteriaOutputRepresentation_DecisionTableSourceCriteriaOutputRepresentation>;
+    sourceObject: string;
+    sourceType: string;
+    status: string;
+    usageType: string;
+}

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

@@ -0,0 +1,44 @@
+import { EligibilityRuleValueInputRepresentation as EligibilityRuleValueInputRepresentation_EligibilityRuleValueInputRepresentation } from './EligibilityRuleValueInputRepresentation';
+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 = "f7f655e1815aee2116786d8189e4c22c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EligibilityRuleInputRepresentation, existing: EligibilityRuleInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EligibilityRuleInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EligibilityRuleInputRepresentationNormalized, incoming: EligibilityRuleInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EligibilityRuleInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input Representation for the Eligibility Rules.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EligibilityRuleInputRepresentationNormalized {
+    /** Custom logic that's used to decide how the input fields are processed */
+    conditionCriteria: string;
+    /** Condition logic that's used for input fields */
+    conditionType: string;
+    /** The unique identifier of the decision table that's associated with the eligibility rule */
+    decisionTableId: string;
+    /** Details of the rule value */
+    ruleValue?: Array<EligibilityRuleValueInputRepresentation_EligibilityRuleValueInputRepresentation>;
+    /** Name of the source object associated with the decision table */
+    sourceObjectName: string;
+    /** The unique identifier of the source object record */
+    sourceObjectRecordId: string;
+}
+/**
+ * Input Representation for the Eligibility Rules.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EligibilityRuleInputRepresentation {
+    conditionCriteria: string;
+    conditionType: string;
+    decisionTableId: string;
+    ruleValue?: Array<EligibilityRuleValueInputRepresentation_EligibilityRuleValueInputRepresentation>;
+    sourceObjectName: string;
+    sourceObjectRecordId: string;
+}

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

@@ -0,0 +1,38 @@
+import { EligibilityRuleDetailsRepresentation as EligibilityRuleDetailsRepresentation_EligibilityRuleDetailsRepresentation } from './EligibilityRuleDetailsRepresentation';
+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 = "046f4d51c0643a7b6b166b3bef730905";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EligibilityRuleMetadataRepresentation, existing: EligibilityRuleMetadataRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EligibilityRuleMetadataRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EligibilityRuleMetadataRepresentationNormalized, incoming: EligibilityRuleMetadataRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EligibilityRuleMetadataRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output representation for Decision Table metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EligibilityRuleMetadataRepresentationNormalized {
+    /** Details of the disqualification decision table */
+    disQualificationDecisionTableDetails: Array<EligibilityRuleDetailsRepresentation_EligibilityRuleDetailsRepresentation>;
+    /** Additional information in the response */
+    message: string;
+    /** Details of the qualification decision table */
+    qualificationDecisionTableDetails: Array<EligibilityRuleDetailsRepresentation_EligibilityRuleDetailsRepresentation>;
+    /** Status of the request */
+    status: string;
+}
+/**
+ * Output representation for Decision Table metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EligibilityRuleMetadataRepresentation {
+    disQualificationDecisionTableDetails: Array<EligibilityRuleDetailsRepresentation_EligibilityRuleDetailsRepresentation>;
+    message: string;
+    qualificationDecisionTableDetails: Array<EligibilityRuleDetailsRepresentation_EligibilityRuleDetailsRepresentation>;
+    status: string;
+}

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

@@ -0,0 +1,40 @@
+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 = "0f1cfcc259ea6033b5fb6ac44728611a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EligibilityRuleValueInputRepresentation, existing: EligibilityRuleValueInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EligibilityRuleValueInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EligibilityRuleValueInputRepresentationNormalized, incoming: EligibilityRuleValueInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EligibilityRuleValueInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input Representation for the Eligibility Rule Values
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EligibilityRuleValueInputRepresentationNormalized {
+    /** Specifies the entity domain field is mapped t */
+    domainEntity: string;
+    /** Specifies the unique identifier of the entity record domain field is mapped to */
+    domainEntityId: string;
+    /** Name of the field in the source object */
+    fieldName: string;
+    /** Value of the field */
+    fieldValue: string;
+    /** The operator applied to an associated decision table field to filter the data */
+    operator: string;
+}
+/**
+ * Input Representation for the Eligibility Rule Values
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EligibilityRuleValueInputRepresentation {
+    domainEntity: string;
+    domainEntityId: string;
+    fieldName: string;
+    fieldValue: string;
+    operator: string;
+}

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

@@ -0,0 +1,47 @@
+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 = 6000;
+export declare const VERSION = "1223e9f0d3678a6dc50dabe1f18066b9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    sourceObjectRecordId: string;
+}
+export type RuleOutputRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialRuleOutputRepresentationNormalizedKeyMetadata = 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): RuleOutputRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: RuleOutputRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: RuleOutputRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: RuleOutputRepresentation, existing: RuleOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): RuleOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: RuleOutputRepresentationNormalized, incoming: RuleOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: RuleOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output Representation for the Eligibility Rules.
+ *
+ * Keys:
+ *    sourceObjectRecordId (string): sourceObjectRecordId
+ */
+export interface RuleOutputRepresentationNormalized {
+    /** Date and time when the rule was created */
+    createdDateTime: string;
+    /** Additional information about the API request execution */
+    message: string;
+    /** The unique identifier of the source object used */
+    sourceObjectRecordId: string;
+    /** Status of the request */
+    status: string;
+}
+/**
+ * Output Representation for the Eligibility Rules.
+ *
+ * Keys:
+ *    sourceObjectRecordId (string): sourceObjectRecordId
+ */
+export interface RuleOutputRepresentation {
+    createdDateTime: string;
+    message: string;
+    sourceObjectRecordId: string;
+    status: string;
+}

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

@@ -0,0 +1,41 @@
+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 = "18e652fe68f957b3d17e599534038578";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: TemplateDependencyConfiguration, existing: TemplateDependencyConfigurationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): TemplateDependencyConfigurationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: TemplateDependencyConfigurationNormalized, incoming: TemplateDependencyConfigurationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: TemplateDependencyConfiguration, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Template dependency configuration with type and variables
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TemplateDependencyConfigurationNormalized {
+    /** API name of the template */
+    templateApiName: string;
+    /** Type of template dependency (Flow) */
+    templateDependencyType?: string;
+    /** Type of template (Intake, Fulfillment) */
+    templateType: string;
+    /** Template variables for deployment */
+    templateVariables?: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * Template dependency configuration with type and variables
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TemplateDependencyConfiguration {
+    templateApiName: string;
+    templateDependencyType?: string;
+    templateType: string;
+    templateVariables?: {
+        [key: string]: unknown;
+    };
+}

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

@@ -0,0 +1,29 @@
+import { TemplateDependencyConfiguration as TemplateDependencyConfiguration_TemplateDependencyConfiguration } from './TemplateDependencyConfiguration';
+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 = "f71a2b1e5938ff8dafe65770a7db4ab7";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: TemplateDeploymentInputRepresentation, existing: TemplateDeploymentInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): TemplateDeploymentInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: TemplateDeploymentInputRepresentationNormalized, incoming: TemplateDeploymentInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: TemplateDeploymentInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Template Deployment Input Representation with flow template configurations
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TemplateDeploymentInputRepresentationNormalized {
+    /** Flow template configurations with type-specific variables */
+    flowTemplates: Array<TemplateDependencyConfiguration_TemplateDependencyConfiguration>;
+}
+/**
+ * Template Deployment Input Representation with flow template configurations
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TemplateDeploymentInputRepresentation {
+    flowTemplates: Array<TemplateDependencyConfiguration_TemplateDependencyConfiguration>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-adapters-service-ecm",
-    "version": "1.389.2",
+    "version": "1.390.0",
     "description": "Service Automation Request",
     "license": "SEE LICENSE IN LICENSE.txt",
     "main": "dist/es/es2018/service-ecm.js",
@@ -40,10 +40,10 @@
         "test:unit": "jest"
     },
     "dependencies": {
-        "@salesforce/lds-bindings": "^1.389.2"
+        "@salesforce/lds-bindings": "^1.390.0"
     },
     "devDependencies": {
-        "@salesforce/lds-compiler-plugins": "^1.389.2"
+        "@salesforce/lds-compiler-plugins": "^1.390.0"
     },
     "nx": {
         "targets": {