@salesforce/lds-adapters-industries-loyalty-engine 0.131.0

package/dist/es/es2018/types/src/generated/types/ProcessRuleConditionFilterCriteriaInputRepresentation.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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "a5b1dc7645986b286ba555271e7545a9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ProcessRuleConditionFilterCriteriaInputRepresentation, existing: ProcessRuleConditionFilterCriteriaInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ProcessRuleConditionFilterCriteriaInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ProcessRuleConditionFilterCriteriaInputRepresentationNormalized, incoming: ProcessRuleConditionFilterCriteriaInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ProcessRuleConditionFilterCriteriaInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ProcessRuleConditionFilterCriteriaInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Loyalty Engine Rule Condition Filter Criteria Input Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleConditionFilterCriteriaInputRepresentationNormalized {
+    /** rule condition filter criteria operator */
+    operator: string;
+    /** rule condition filter criteria sequence */
+    sequence: number;
+    /** rule condition filter criteria source field name */
+    sourceFieldName: string;
+    /** rule condition filter criteria value */
+    value: string;
+    /** rule condition filter criteria value type */
+    valueType: string;
+}
+/**
+ * Loyalty Engine Rule Condition Filter Criteria Input Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleConditionFilterCriteriaInputRepresentation {
+    operator: string;
+    sequence: number;
+    sourceFieldName: string;
+    value: string;
+    valueType: string;
+}

package/dist/es/es2018/types/src/generated/types/ProcessRuleConditionFilterCriteriaRepresentation.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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "29004ac048f0a24f78d312b64311dbbc";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ProcessRuleConditionFilterCriteriaRepresentation, existing: ProcessRuleConditionFilterCriteriaRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ProcessRuleConditionFilterCriteriaRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ProcessRuleConditionFilterCriteriaRepresentationNormalized, incoming: ProcessRuleConditionFilterCriteriaRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ProcessRuleConditionFilterCriteriaRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ProcessRuleConditionFilterCriteriaRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Loyalty Engine Rule Condition Filter Criteria Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleConditionFilterCriteriaRepresentationNormalized {
+    /** rule condition filter criteria operator */
+    operator: string;
+    /** rule condition filter criteria sequence */
+    sequence: number;
+    /** rule condition filter criteria source field name */
+    sourceFieldName: string;
+    /** rule condition filter criteria value */
+    value: string | null;
+    /** rule condition filter criteria value type */
+    valueType: string;
+}
+/**
+ * Loyalty Engine Rule Condition Filter Criteria Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleConditionFilterCriteriaRepresentation {
+    operator: string;
+    sequence: number;
+    sourceFieldName: string;
+    value: string | null;
+    valueType: string;
+}

package/dist/es/es2018/types/src/generated/types/ProcessRuleConditionInputRepresentation.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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "d8db2acdfe1a2d358b19c628dccc33ff";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ProcessRuleConditionInputRepresentation, existing: ProcessRuleConditionInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ProcessRuleConditionInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ProcessRuleConditionInputRepresentationNormalized, incoming: ProcessRuleConditionInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ProcessRuleConditionInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ProcessRuleConditionInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Loyalty Engine Rule Condition Input Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleConditionInputRepresentationNormalized {
+    /** condition type */
+    conditionType: string;
+    /** rule condition filter criteria */
+    criteria: Array<{}>;
+    /** rule condition filter condition */
+    filterCondition: string;
+    /** rule condition filter expression */
+    filterExpression: string;
+    /** rule condition name */
+    name: string;
+}
+/**
+ * Loyalty Engine Rule Condition Input Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleConditionInputRepresentation {
+    conditionType: string;
+    criteria: Array<{}>;
+    filterCondition: string;
+    filterExpression: string;
+    name: string;
+}

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

@@ -0,0 +1,42 @@
+import { ProcessRuleConditionFilterCriteriaRepresentation as ProcessRuleConditionFilterCriteriaRepresentation_ProcessRuleConditionFilterCriteriaRepresentation } from './ProcessRuleConditionFilterCriteriaRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "6c211af6ed5d5f2445db5e68f3ddeadd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ProcessRuleConditionRepresentation, existing: ProcessRuleConditionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ProcessRuleConditionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ProcessRuleConditionRepresentationNormalized, incoming: ProcessRuleConditionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ProcessRuleConditionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ProcessRuleConditionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Loyalty Engine Rule Condition Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleConditionRepresentationNormalized {
+    /** rule condition type */
+    conditionType: string;
+    /** rule condition filter criteria */
+    criteria: Array<ProcessRuleConditionFilterCriteriaRepresentation_ProcessRuleConditionFilterCriteriaRepresentation>;
+    /** rule condition's filter condition */
+    filterCondition: string | null;
+    /** rule condition's filter expression */
+    filterExpression: string | null;
+    /** rule condition name */
+    name: string;
+}
+/**
+ * Loyalty Engine Rule Condition Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleConditionRepresentation {
+    conditionType: string;
+    criteria: Array<ProcessRuleConditionFilterCriteriaRepresentation_ProcessRuleConditionFilterCriteriaRepresentation>;
+    filterCondition: string | null;
+    filterExpression: string | null;
+    name: string;
+}

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

@@ -0,0 +1,78 @@
+import { ProcessRuleActionRepresentation as ProcessRuleActionRepresentation_ProcessRuleActionRepresentation } from './ProcessRuleActionRepresentation';
+import { ProcessRuleConditionRepresentation as ProcessRuleConditionRepresentation_ProcessRuleConditionRepresentation } from './ProcessRuleConditionRepresentation';
+import { ProcessRuleStepMappingRepresentation as ProcessRuleStepMappingRepresentation_ProcessRuleStepMappingRepresentation } from './ProcessRuleStepMappingRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 10000;
+export declare const VERSION = "37ac5c7e7b5763ded042c498e5de144a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ProcessRuleDetailRepresentation, existing: ProcessRuleDetailRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ProcessRuleDetailRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ProcessRuleDetailRepresentationNormalized, incoming: ProcessRuleDetailRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ProcessRuleDetailRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ProcessRuleDetailRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Loyalty Engine Rule GET Response Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleDetailRepresentationNormalized {
+    /** rule actions */
+    actions: Array<ProcessRuleActionRepresentation_ProcessRuleActionRepresentation>;
+    /** rule conditions */
+    conditions: Array<ProcessRuleConditionRepresentation_ProcessRuleConditionRepresentation>;
+    /** Description */
+    description: string | null;
+    /** EndDate */
+    endDate: string | null;
+    /** Rule Name */
+    name: string;
+    /** Next Rule Id */
+    nextRuleId: string | null;
+    /** Next Rule Name */
+    nextRuleName: string | null;
+    /** Previous Rule Id */
+    previousRuleId: string | null;
+    /** Previous Rule Name */
+    previousRuleName: string | null;
+    /** Process Id */
+    processId: string | null;
+    /** Process Name */
+    processName: string | null;
+    /** Promotion Id */
+    promotionId: string | null;
+    /** Promotion Name */
+    promotionName: string | null;
+    /** Start Date */
+    startDate: string;
+    /** Status */
+    status: string;
+    /** rule step mappings */
+    stepMappings: Array<ProcessRuleStepMappingRepresentation_ProcessRuleStepMappingRepresentation>;
+}
+/**
+ * Loyalty Engine Rule GET Response Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleDetailRepresentation {
+    actions: Array<ProcessRuleActionRepresentation_ProcessRuleActionRepresentation>;
+    conditions: Array<ProcessRuleConditionRepresentation_ProcessRuleConditionRepresentation>;
+    description: string | null;
+    endDate: string | null;
+    name: string;
+    nextRuleId: string | null;
+    nextRuleName: string | null;
+    previousRuleId: string | null;
+    previousRuleName: string | null;
+    processId: string | null;
+    processName: string | null;
+    promotionId: string | null;
+    promotionName: string | null;
+    startDate: string;
+    status: string;
+    stepMappings: Array<ProcessRuleStepMappingRepresentation_ProcessRuleStepMappingRepresentation>;
+}

package/dist/es/es2018/types/src/generated/types/ProcessRuleErrorRepresentation.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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "4c335cae0d36875f624a306e46b95127";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ProcessRuleErrorRepresentation, existing: ProcessRuleErrorRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ProcessRuleErrorRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ProcessRuleErrorRepresentationNormalized, incoming: ProcessRuleErrorRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ProcessRuleErrorRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ProcessRuleErrorRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Loyalty Engine Rule POST Response Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleErrorRepresentationNormalized {
+    /** criteria sequence */
+    criteriaSequence: number | null;
+    /** error message */
+    error: string;
+    /** field name */
+    fieldName: string | null;
+    /** rule resource type */
+    resource: string;
+    /** associated step name */
+    stepName: string | null;
+}
+/**
+ * Loyalty Engine Rule POST Response Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleErrorRepresentation {
+    criteriaSequence: number | null;
+    error: string;
+    fieldName: string | null;
+    resource: string;
+    stepName: string | null;
+}

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

@@ -0,0 +1,57 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 10000;
+export declare const VERSION = "09be66d81841fc6406561f5013bc8a54";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ProcessRuleInputRepresentation, existing: ProcessRuleInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ProcessRuleInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ProcessRuleInputRepresentationNormalized, incoming: ProcessRuleInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ProcessRuleInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ProcessRuleInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Loyalty Engine Rule Input Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleInputRepresentationNormalized {
+    /** rule actions */
+    actions: Array<{}>;
+    /** rule conditions */
+    conditions: Array<{}>;
+    /** Description */
+    description: string;
+    /** EndDate */
+    endDate?: string | null;
+    /** Rule Name */
+    name: string;
+    /** Previous Rule Id */
+    previousRuleId: string;
+    /** Promotion Id */
+    promotionId?: string;
+    /** Start Date */
+    startDate: string;
+    /** Status */
+    status: string;
+    /** rule step mappings */
+    stepMappings: Array<{}>;
+}
+/**
+ * Loyalty Engine Rule Input Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleInputRepresentation {
+    actions: Array<{}>;
+    conditions: Array<{}>;
+    description: string;
+    endDate?: string | null;
+    name: string;
+    previousRuleId: string;
+    promotionId?: string;
+    startDate: string;
+    status: string;
+    stepMappings: Array<{}>;
+}

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

@@ -0,0 +1,49 @@
+import { ProcessRuleErrorRepresentation as ProcessRuleErrorRepresentation_ProcessRuleErrorRepresentation } from './ProcessRuleErrorRepresentation';
+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 = 10000;
+export declare const VERSION = "def3b2fb07871a4b3e8a02fe7d66f0c1";
+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 | null;
+}
+export type ProcessRuleStatusRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialProcessRuleStatusRepresentationNormalizedKeyMetadata = 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): ProcessRuleStatusRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ProcessRuleStatusRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ProcessRuleStatusRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ProcessRuleStatusRepresentation, existing: ProcessRuleStatusRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ProcessRuleStatusRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ProcessRuleStatusRepresentationNormalized, incoming: ProcessRuleStatusRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ProcessRuleStatusRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ProcessRuleStatusRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Loyalty Engine Rule POST Response Representation
+ *
+ * Keys:
+ *    id (string | null): ruleId
+ */
+export interface ProcessRuleStatusRepresentationNormalized {
+    /** validation errors if found */
+    errors: Array<ProcessRuleErrorRepresentation_ProcessRuleErrorRepresentation>;
+    /** general success/error message */
+    message: string | null;
+    /** program process rule id */
+    ruleId: string | null;
+    /** request response status */
+    status: string | null;
+}
+/**
+ * Loyalty Engine Rule POST Response Representation
+ *
+ * Keys:
+ *    id (string | null): ruleId
+ */
+export interface ProcessRuleStatusRepresentation {
+    errors: Array<ProcessRuleErrorRepresentation_ProcessRuleErrorRepresentation>;
+    message: string | null;
+    ruleId: string | null;
+    status: string | null;
+}

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

@@ -0,0 +1,35 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "87540b516b7806273821eae33eb4dcc9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ProcessRuleStepMappingInputRepresentation, existing: ProcessRuleStepMappingInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ProcessRuleStepMappingInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ProcessRuleStepMappingInputRepresentationNormalized, incoming: ProcessRuleStepMappingInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ProcessRuleStepMappingInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ProcessRuleStepMappingInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Loyalty Engine Rule Step Mapping Input Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleStepMappingInputRepresentationNormalized {
+    /** associate step name */
+    associatedStep: string;
+    /** parent step name */
+    parentStep: string;
+    /** step sequence number */
+    sequence: number;
+}
+/**
+ * Loyalty Engine Rule Step Mapping Input Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleStepMappingInputRepresentation {
+    associatedStep: string;
+    parentStep: string;
+    sequence: number;
+}

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

@@ -0,0 +1,35 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "926636ffabc7e19b9eb8632b3e6ccbec";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ProcessRuleStepMappingRepresentation, existing: ProcessRuleStepMappingRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ProcessRuleStepMappingRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ProcessRuleStepMappingRepresentationNormalized, incoming: ProcessRuleStepMappingRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ProcessRuleStepMappingRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ProcessRuleStepMappingRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Loyalty Engine Rule Step Mapping Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleStepMappingRepresentationNormalized {
+    /** associated step name */
+    associatedStep: string;
+    /** parent step name */
+    parentStep: string | null;
+    /** step sequence number */
+    sequence: number;
+}
+/**
+ * Loyalty Engine Rule Step Mapping Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProcessRuleStepMappingRepresentation {
+    associatedStep: string;
+    parentStep: string | null;
+    sequence: number;
+}

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

@@ -0,0 +1,39 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, ResourceIngest as $64$luvio_engine_ResourceIngest, FragmentSelection as $64$luvio_engine_FragmentSelection, LinkSelection as $64$luvio_engine_LinkSelection, StoreLink as $64$luvio_engine_StoreLink, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+import { ProcessRuleInputRepresentation as ProcessRuleInputRepresentation_ProcessRuleInputRepresentation } from './ProcessRuleInputRepresentation';
+export declare const VERSION = "50111537d527a2159a87cb0f776b049a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ProgramProcessRule, existing: ProgramProcessRuleNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ProgramProcessRuleNormalized;
+export interface DynamicIngestParams {
+    programProcessRule: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: ProgramProcessRule, existing: ProgramProcessRuleNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => ProgramProcessRuleNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    programProcessRule?: $64$luvio_engine_LinkSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ProgramProcessRuleNormalized, incoming: ProgramProcessRuleNormalized): boolean;
+export declare function deepFreeze(input: ProgramProcessRule): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ProgramProcessRule, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * A wrapper around the ProcessRuleInputRepresentation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProgramProcessRuleNormalized {
+    /** The Oas Body Name for request body representation */
+    programProcessRule: $64$luvio_engine_StoreLink;
+}
+/**
+ * A wrapper around the ProcessRuleInputRepresentation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ProgramProcessRule {
+    programProcessRule: ProcessRuleInputRepresentation_ProcessRuleInputRepresentation;
+}

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

@@ -0,0 +1,33 @@
+import { PointsSummaryRepresentation as PointsSummaryRepresentation_PointsSummaryRepresentation } from './PointsSummaryRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "233c2f5333b90951799790d482a7116a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SummaryRepresentation, existing: SummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SummaryRepresentationNormalized, incoming: SummaryRepresentationNormalized): boolean;
+export declare function deepFreeze(input: SummaryRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: SummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Process or Rule Summary
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SummaryRepresentationNormalized {
+    /** Point Summary. */
+    pointsSummary: Array<PointsSummaryRepresentation_PointsSummaryRepresentation>;
+    /** The number of vouchers that have been issued to the loyalty program member associated with the transaction journal.. */
+    vouchersIssuedCount: number;
+}
+/**
+ * Process or Rule Summary
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SummaryRepresentation {
+    pointsSummary: Array<PointsSummaryRepresentation_PointsSummaryRepresentation>;
+    vouchersIssuedCount: number;
+}

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

@@ -0,0 +1,30 @@
+import { TransactionJournalRepresentation as TransactionJournalRepresentation_TransactionJournalRepresentation } from './TransactionJournalRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "dfc9913faf0cedc61107fca69658f5c1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: TransactionJournalOutputRepresentation, existing: TransactionJournalOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): TransactionJournalOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: TransactionJournalOutputRepresentationNormalized, incoming: TransactionJournalOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: TransactionJournalOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: TransactionJournalOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Wrapper for the Transaction Journal Simulation Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TransactionJournalOutputRepresentationNormalized {
+    /** Details of the Transaction Journal records that have been created. */
+    transactionJournals: Array<TransactionJournalRepresentation_TransactionJournalRepresentation>;
+}
+/**
+ * Wrapper for the Transaction Journal Simulation Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TransactionJournalOutputRepresentation {
+    transactionJournals: Array<TransactionJournalRepresentation_TransactionJournalRepresentation>;
+}

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

@@ -0,0 +1,40 @@
+import { SummaryRepresentation as SummaryRepresentation_SummaryRepresentation } from './SummaryRepresentation';
+import { LoyaltyProgramProcessRuleRepresentation as LoyaltyProgramProcessRuleRepresentation_LoyaltyProgramProcessRuleRepresentation } from './LoyaltyProgramProcessRuleRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "02fbbb3136329b4111f875519b945a58";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: TransactionJournalRepresentation, existing: TransactionJournalRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): TransactionJournalRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: TransactionJournalRepresentationNormalized, incoming: TransactionJournalRepresentationNormalized): boolean;
+export declare function deepFreeze(input: TransactionJournalRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: TransactionJournalRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Wrapper for the Transaction Journal
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TransactionJournalRepresentationNormalized {
+    /** The summary of how loyalty program process rules have processed transaction journal. */
+    executionSummary: SummaryRepresentation_SummaryRepresentation;
+    /** The ID of the loyalty program process that has processed the transaction journal. */
+    processId: string;
+    /** The name of the loyalty program process that has processed the transaction journal. */
+    processName: string;
+    /** List of loyalty program process rules that have processed the transaction journal. */
+    processRules: Array<LoyaltyProgramProcessRuleRepresentation_LoyaltyProgramProcessRuleRepresentation>;
+}
+/**
+ * Wrapper for the Transaction Journal
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TransactionJournalRepresentation {
+    executionSummary: SummaryRepresentation_SummaryRepresentation;
+    processId: string;
+    processName: string;
+    processRules: Array<LoyaltyProgramProcessRuleRepresentation_LoyaltyProgramProcessRuleRepresentation>;
+}