@salesforce/lds-adapters-sfap-einstein-copilot-bot 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 = "einstein-copilot-bot";

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

@@ -0,0 +1,26 @@
+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_getEinsteinBotsV1Status_ResourceRequestConfig } from '../resources/getEinsteinBotsV1Status';
+import { Status as types_Status_Status } from '../types/Status';
+export declare const adapterName = "getStatus";
+export declare const getStatus_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const getStatus_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface GetStatusConfig {
+}
+export declare const createResourceParams: (config: GetStatusConfig) => resources_getEinsteinBotsV1Status_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetStatusConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: GetStatusConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetStatusConfig>): adapter$45$utils_Untrusted<GetStatusConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetStatusConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: GetStatusConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: GetStatusConfig): $64$luvio_engine_Snapshot<types_Status_Status, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: GetStatusConfig, resourceParams: resources_getEinsteinBotsV1Status_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_Status_Status>): Promise<import("@luvio/engine").FulfilledSnapshot<types_Status_Status, {}> | import("@luvio/engine").StaleSnapshot<types_Status_Status, {}> | import("@luvio/engine").PendingSnapshot<types_Status_Status, any>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: GetStatusConfig, resourceParams: resources_getEinsteinBotsV1Status_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetStatusConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_Status_Status, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: GetStatusConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_Status_Status, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_Status_Status>): $64$luvio_engine_Snapshot<types_Status_Status, any>;
+export declare const getStatusAdapterFactory: $64$luvio_engine_AdapterFactory<GetStatusConfig, types_Status_Status>;

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

@@ -0,0 +1,30 @@
+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 { TextInitMessage as types_TextInitMessage_TextInitMessage } from '../types/TextInitMessage';
+import { ForceConfig as types_ForceConfig_ForceConfig } from '../types/ForceConfig';
+import { ResponseOptions as types_ResponseOptions_ResponseOptions } from '../types/ResponseOptions';
+import { RichContentCapability as types_RichContentCapability_RichContentCapability } from '../types/RichContentCapability';
+import { Referrer as types_Referrer_Referrer } from '../types/Referrer';
+import { ResourceRequestConfig as resources_ResourceRequestConfig } from '../resources/postEinsteinBotsV1V5.3.0BotsSessionsByBotId';
+import { ResponseEnvelope as types_ResponseEnvelope_ResponseEnvelope } from '../types/ResponseEnvelope';
+export declare const adapterName = "startSession";
+export declare const startSession_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const startSession_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface StartSessionConfig {
+    botId: string;
+    xOrgId: string;
+    xRequestID?: string;
+    externalSessionKey: string;
+    message?: types_TextInitMessage_TextInitMessage;
+    forceConfig: types_ForceConfig_ForceConfig;
+    responseOptions?: types_ResponseOptions_ResponseOptions;
+    tz?: string | null;
+    variables?: Array<unknown>;
+    richContentCapabilities: types_RichContentCapability_RichContentCapability;
+    referrers?: Array<types_Referrer_Referrer>;
+}
+export declare const createResourceParams: (config: StartSessionConfig) => resources_ResourceRequestConfig;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<StartSessionConfig>): adapter$45$utils_Untrusted<StartSessionConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): StartSessionConfig | null;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: StartSessionConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<import("@luvio/engine").FulfilledSnapshot<types_ResponseEnvelope_ResponseEnvelope, {}> | import("@luvio/engine").StaleSnapshot<types_ResponseEnvelope_ResponseEnvelope, {}> | import("@luvio/engine").PendingSnapshot<types_ResponseEnvelope_ResponseEnvelope, any>>;
+export declare const startSessionAdapterFactory: $64$luvio_engine_AdapterFactory<StartSessionConfig, types_ResponseEnvelope_ResponseEnvelope>;

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

@@ -0,0 +1,2 @@
+export { getStatusAdapterFactory } from '../adapters/getStatus';
+export { startSessionAdapterFactory } from '../adapters/startSession';

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

@@ -0,0 +1,4 @@
+declare let getStatus: any;
+declare let startSession: any;
+declare let getStatus_imperative: any;
+export { getStatus, startSession, getStatus_imperative };

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

@@ -0,0 +1,12 @@
+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 { Status as types_Status_Status } from '../types/Status';
+export interface ResourceRequestConfig {
+}
+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_Status_Status): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_Status_Status>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_Status_Status>): $64$luvio_engine_FulfilledSnapshot<types_Status_Status, {}> | $64$luvio_engine_StaleSnapshot<types_Status_Status, {}> | $64$luvio_engine_PendingSnapshot<types_Status_Status, any>;
+export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_Status_Status>): $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/postEinsteinBotsV1V5.3.0BotsSessionsByBotId.d.ts

@@ -0,0 +1,31 @@
+import { TextInitMessage as types_TextInitMessage_TextInitMessage } from '../types/TextInitMessage';
+import { ForceConfig as types_ForceConfig_ForceConfig } from '../types/ForceConfig';
+import { ResponseOptions as types_ResponseOptions_ResponseOptions } from '../types/ResponseOptions';
+import { RichContentCapability as types_RichContentCapability_RichContentCapability } from '../types/RichContentCapability';
+import { Referrer as types_Referrer_Referrer } from '../types/Referrer';
+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 { ResponseEnvelope as types_ResponseEnvelope_ResponseEnvelope } from '../types/ResponseEnvelope';
+export interface ResourceRequestConfig {
+    urlParams: {
+        botId: string;
+    };
+    body: {
+        externalSessionKey: string;
+        message?: types_TextInitMessage_TextInitMessage;
+        forceConfig: types_ForceConfig_ForceConfig;
+        responseOptions?: types_ResponseOptions_ResponseOptions;
+        tz?: string | null;
+        variables?: Array<unknown>;
+        richContentCapabilities: types_RichContentCapability_RichContentCapability;
+        referrers?: Array<types_Referrer_Referrer>;
+    };
+    headers: {
+        xOrgId: string;
+        xRequestID?: string;
+    };
+}
+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_ResponseEnvelope_ResponseEnvelope): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_ResponseEnvelope_ResponseEnvelope>): $64$luvio_engine_FulfilledSnapshot<types_ResponseEnvelope_ResponseEnvelope, {}> | $64$luvio_engine_StaleSnapshot<types_ResponseEnvelope_ResponseEnvelope, {}> | $64$luvio_engine_PendingSnapshot<types_ResponseEnvelope_ResponseEnvelope, any>;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

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

@@ -0,0 +1,43 @@
+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 = "e16488ec2f9192d6491f7bcf4546f337";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: Error, existing: ErrorNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ErrorNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ErrorNormalized, incoming: ErrorNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: Error, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ErrorNormalized {
+    /** Error class name. */
+    error: string;
+    /** Exception message. */
+    message: string;
+    /** Request path. */
+    path: string;
+    /** Request ID. A UUID in string format to help with request tracking. */
+    requestId: string;
+    /** HTTP status. */
+    status: number;
+    /** Unix timestamp. */
+    timestamp: number;
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface Error {
+    error: string;
+    message: string;
+    path: string;
+    requestId: string;
+    status: number;
+    timestamp: number;
+}

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

@@ -0,0 +1,28 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "f89f5e8bcaf8bf7daf3ac445e7616130";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ForceConfig, existing: ForceConfigNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ForceConfigNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ForceConfigNormalized, incoming: ForceConfigNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ForceConfig, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * API configuration parameters.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ForceConfigNormalized {
+    /** Instance URL of your Salesforce org. You can find the value in the **ForceConfig Endpoint** field of the **Add Connection** dialog when you add the connected app to the bot (see [Get Started with Einstein Bot API](https://developer.salesforce.com/docs/service/einstein-bot-api/guide/prerequisites.html)). */
+    endpoint: string;
+}
+/**
+ * API configuration parameters.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ForceConfig {
+    endpoint: string;
+}

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

@@ -0,0 +1,27 @@
+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 = "b0d840399c685f89c1b527632e093e2d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: FormatTypeCapability, existing: FormatTypeCapabilityNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): FormatTypeCapabilityNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: FormatTypeCapabilityNormalized, incoming: FormatTypeCapabilityNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: FormatTypeCapability, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FormatTypeCapabilityNormalized {
+    formatType: string;
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FormatTypeCapability {
+    formatType: string;
+}

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

@@ -0,0 +1,28 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "e83b5929e31be375ae27fe73bb3382f9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: HyperLink, existing: HyperLinkNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): HyperLinkNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: HyperLinkNormalized, incoming: HyperLinkNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: HyperLink, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Hyperlink object included in the Links schema
+ *
+ * Keys:
+ *    (none)
+ */
+export interface HyperLinkNormalized {
+    /** Link to the endpoint */
+    href?: string;
+}
+/**
+ * Hyperlink object included in the Links schema
+ *
+ * Keys:
+ *    (none)
+ */
+export interface HyperLink {
+    href?: string;
+}

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

@@ -0,0 +1,46 @@
+import { ForceConfig as ForceConfig_ForceConfig } from './ForceConfig';
+import { TextInitMessage as TextInitMessage_TextInitMessage } from './TextInitMessage';
+import { Referrer as Referrer_Referrer } from './Referrer';
+import { ResponseOptions as ResponseOptions_ResponseOptions } from './ResponseOptions';
+import { RichContentCapability as RichContentCapability_RichContentCapability } from './RichContentCapability';
+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 = "dc68d9d82a901a75667266d4077a7ffb";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: InitMessageEnvelope, existing: InitMessageEnvelopeNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): InitMessageEnvelopeNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: InitMessageEnvelopeNormalized, incoming: InitMessageEnvelopeNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: InitMessageEnvelope, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface InitMessageEnvelopeNormalized {
+    externalSessionKey: string;
+    forceConfig: ForceConfig_ForceConfig;
+    message?: TextInitMessage_TextInitMessage;
+    referrers?: Array<Referrer_Referrer>;
+    responseOptions?: ResponseOptions_ResponseOptions;
+    richContentCapabilities: RichContentCapability_RichContentCapability;
+    tz?: string | null;
+    variables?: Array<unknown>;
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface InitMessageEnvelope {
+    externalSessionKey: string;
+    forceConfig: ForceConfig_ForceConfig;
+    message?: TextInitMessage_TextInitMessage;
+    referrers?: Array<Referrer_Referrer>;
+    responseOptions?: ResponseOptions_ResponseOptions;
+    richContentCapabilities: RichContentCapability_RichContentCapability;
+    tz?: string | null;
+    variables?: Array<unknown>;
+}

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

@@ -0,0 +1,34 @@
+import { HyperLink as HyperLink_HyperLink } from './HyperLink';
+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 = "b2628db4df840dd65695e7c0fa116ba0";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: Links, existing: LinksNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): LinksNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: LinksNormalized, incoming: LinksNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: Links, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * List of Einstein Bots API endpoints for HATEOS compliancy.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface LinksNormalized {
+    feedback?: HyperLink_HyperLink;
+    messages?: HyperLink_HyperLink;
+    self: HyperLink_HyperLink;
+    session?: HyperLink_HyperLink;
+}
+/**
+ * List of Einstein Bots API endpoints for HATEOS compliancy.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface Links {
+    feedback?: HyperLink_HyperLink;
+    messages?: HyperLink_HyperLink;
+    self: HyperLink_HyperLink;
+    session?: HyperLink_HyperLink;
+}

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

@@ -0,0 +1,30 @@
+import { FormatTypeCapability as FormatTypeCapability_FormatTypeCapability } from './FormatTypeCapability';
+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 = "48befb4ebdfd4840ab9979503a970e3f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MessageTypeCapability, existing: MessageTypeCapabilityNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MessageTypeCapabilityNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MessageTypeCapabilityNormalized, incoming: MessageTypeCapabilityNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: MessageTypeCapability, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MessageTypeCapabilityNormalized {
+    formatTypes: Array<FormatTypeCapability_FormatTypeCapability>;
+    messageType: string;
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MessageTypeCapability {
+    formatTypes: Array<FormatTypeCapability_FormatTypeCapability>;
+    messageType: string;
+}

package/dist/es/es2018/types/src/generated/types/NormalizedEntity.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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "7c8373d2df008bda97299d299ec1812c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: NormalizedEntity, existing: NormalizedEntityNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): NormalizedEntityNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: NormalizedEntityNormalized, incoming: NormalizedEntityNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: NormalizedEntity, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface NormalizedEntityNormalized {
+    /** Probability number that the AI assigns to this entity. */
+    confidenceScore: number;
+    entitySource?: string;
+    type: string;
+    /** Value of the entity that the customer enters. */
+    value: string;
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface NormalizedEntity {
+    confidenceScore: number;
+    entitySource?: string;
+    type: string;
+    value: string;
+}

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

@@ -0,0 +1,33 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "dc0fc09de80bfd4fd35d43e3e123eb83";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: NormalizedIntent, existing: NormalizedIntentNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): NormalizedIntentNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: NormalizedIntentNormalized, incoming: NormalizedIntentNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: NormalizedIntent, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface NormalizedIntentNormalized {
+    /** Probability number that the AI assigns to this intent. */
+    confidenceScore: number;
+    intentSource: string;
+    /** Name or ID of the intent. */
+    label: string;
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface NormalizedIntent {
+    confidenceScore: number;
+    intentSource: string;
+    label: string;
+}

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

@@ -0,0 +1,31 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "26c5bad610fae58c46a13dc7043d8d74";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: Referrer, existing: ReferrerNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ReferrerNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ReferrerNormalized, incoming: ReferrerNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: Referrer, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ReferrerNormalized {
+    /** Referrer type. */
+    type: string;
+    /** ID of referrer. */
+    value: string;
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface Referrer {
+    type: string;
+    value: string;
+}

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

@@ -0,0 +1,59 @@
+import { Links as Links_Links } from './Links';
+import { NormalizedEntity as NormalizedEntity_NormalizedEntity } from './NormalizedEntity';
+import { NormalizedIntent as NormalizedIntent_NormalizedIntent } from './NormalizedIntent';
+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 = 500;
+export declare const VERSION = "629ac931b0021d4de378c8cafc6a7213";
+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 ResponseEnvelopeNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialResponseEnvelopeNormalizedKeyMetadata = 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): ResponseEnvelopeNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ResponseEnvelope): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ResponseEnvelope): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ResponseEnvelope, existing: ResponseEnvelopeNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ResponseEnvelopeNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ResponseEnvelopeNormalized, incoming: ResponseEnvelopeNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ResponseEnvelope, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    id (string): sessionId
+ */
+export interface ResponseEnvelopeNormalized {
+    _links: Links_Links;
+    botVersion: string;
+    entities?: Array<NormalizedEntity_NormalizedEntity>;
+    intents?: Array<NormalizedIntent_NormalizedIntent>;
+    /** Messages from the bot. */
+    messages: Array<unknown>;
+    /** Session metrics. */
+    metrics?: {};
+    /** Sequence IDs of messages that the bot processed. Except for the initial request to start the session, all requests require a `sequenceId`. */
+    processedSequenceIds: Array<number>;
+    sessionId: string;
+    variables?: Array<unknown>;
+}
+/**
+ *
+ *
+ * Keys:
+ *    id (string): sessionId
+ */
+export interface ResponseEnvelope {
+    _links: Links_Links;
+    botVersion: string;
+    entities?: Array<NormalizedEntity_NormalizedEntity>;
+    intents?: Array<NormalizedIntent_NormalizedIntent>;
+    messages: Array<unknown>;
+    metrics?: {};
+    processedSequenceIds: Array<number>;
+    sessionId: string;
+    variables?: Array<unknown>;
+}

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

@@ -0,0 +1,37 @@
+import { ResponseOptionsVariables as ResponseOptionsVariables_ResponseOptionsVariables } from './ResponseOptionsVariables';
+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 = "e006d9c69ddb8d985946f110bde7b512";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ResponseOptions, existing: ResponseOptionsNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ResponseOptionsNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ResponseOptionsNormalized, incoming: ResponseOptionsNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ResponseOptions, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Configuration of additional information returned in the response payload.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ResponseOptionsNormalized {
+    /** Indicates whether to include all entities detected when processing the current request. */
+    entities?: boolean;
+    /** Indicates whether to include all intents detected when processing the current request. */
+    intents?: boolean;
+    /** Indicates whether to include metrics in the response. */
+    metrics?: boolean;
+    variables?: ResponseOptionsVariables_ResponseOptionsVariables;
+}
+/**
+ * Configuration of additional information returned in the response payload.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ResponseOptions {
+    entities?: boolean;
+    intents?: boolean;
+    metrics?: boolean;
+    variables?: ResponseOptionsVariables_ResponseOptionsVariables;
+}