@salesforce/lds-adapters-service-einsteinllm 0.1.0-dev1

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

@@ -0,0 +1,37 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "6458d624e5a1691821c764b6de0badb3";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EinsteinPromptTemplateGenerationsErrorRepresentation, existing: EinsteinPromptTemplateGenerationsErrorRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinPromptTemplateGenerationsErrorRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinPromptTemplateGenerationsErrorRepresentationNormalized, incoming: EinsteinPromptTemplateGenerationsErrorRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinPromptTemplateGenerationsErrorRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Error output of a EinsteinPromptTemplateGeneration request
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateGenerationsErrorRepresentationNormalized {
+    /** This is the error message meant for client consumption. It may differ from the Gateway Error Message */
+    errorMessage: string;
+    /** HTTP Error Code classifying the error */
+    httpErrorCode: string;
+    /** This is the localized error message. */
+    localizedErrorMessage?: string;
+    /** The message code received from the LLM Gateway */
+    messageCode: string;
+}
+/**
+ * Error output of a EinsteinPromptTemplateGeneration request
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateGenerationsErrorRepresentation {
+    errorMessage: string;
+    httpErrorCode: string;
+    localizedErrorMessage?: string;
+    messageCode: string;
+}

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

@@ -0,0 +1,45 @@
+import { EinsteinLlmAdditionalConfigInputRepresentation as EinsteinLlmAdditionalConfigInputRepresentation_EinsteinLlmAdditionalConfigInputRepresentation } from './EinsteinLlmAdditionalConfigInputRepresentation';
+import { WrappedValueMap as WrappedValueMap_WrappedValueMap } from './WrappedValueMap';
+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 = "a2cd7e0282d520ef2004c8eb2a8178b1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EinsteinPromptTemplateGenerationsInputRepresentation, existing: EinsteinPromptTemplateGenerationsInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinPromptTemplateGenerationsInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinPromptTemplateGenerationsInputRepresentationNormalized, incoming: EinsteinPromptTemplateGenerationsInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinPromptTemplateGenerationsInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for generating prompt template responses with Einstein LLM
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateGenerationsInputRepresentationNormalized {
+    /** Additional configuration to fine tune model parameters */
+    additionalConfig?: EinsteinLlmAdditionalConfigInputRepresentation_EinsteinLlmAdditionalConfigInputRepresentation;
+    /** Dictionary of input parameters to generate prompt from prompt template. */
+    inputParams: WrappedValueMap_WrappedValueMap;
+    /** Whether to generate prompt template preview  by resolving merge fields */
+    isPreview: boolean;
+    /** Output Language */
+    outputLanguage?: string;
+    /** LLM Provider */
+    provider?: string;
+    /** When this flag is true, mergeFieldInformation will be added to the LLM Generations Response output, which will be used to show annotations in the resolved prompt. */
+    showGroundingMetadataInResolvedPrompt?: boolean;
+}
+/**
+ * Input representation for generating prompt template responses with Einstein LLM
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateGenerationsInputRepresentation {
+    additionalConfig?: EinsteinLlmAdditionalConfigInputRepresentation_EinsteinLlmAdditionalConfigInputRepresentation;
+    inputParams: WrappedValueMap_WrappedValueMap;
+    isPreview: boolean;
+    outputLanguage?: string;
+    provider?: string;
+    showGroundingMetadataInResolvedPrompt?: boolean;
+}

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

@@ -0,0 +1,28 @@
+import { EinsteinPromptTemplateGenerationsInputRepresentation as EinsteinPromptTemplateGenerationsInputRepresentation_EinsteinPromptTemplateGenerationsInputRepresentation } from './EinsteinPromptTemplateGenerationsInputRepresentation';
+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 = "0aed7a000488d7cbb2dc18d8d5900f16";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EinsteinPromptTemplateGenerationsInputWrapperRepresentation, existing: EinsteinPromptTemplateGenerationsInputWrapperRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinPromptTemplateGenerationsInputWrapperRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinPromptTemplateGenerationsInputWrapperRepresentationNormalized, incoming: EinsteinPromptTemplateGenerationsInputWrapperRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinPromptTemplateGenerationsInputWrapperRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input wrapper for prompt template generations input representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateGenerationsInputWrapperRepresentationNormalized {
+    promptTemplateGenerationsInput: EinsteinPromptTemplateGenerationsInputRepresentation_EinsteinPromptTemplateGenerationsInputRepresentation;
+}
+/**
+ * Input wrapper for prompt template generations input representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateGenerationsInputWrapperRepresentation {
+    promptTemplateGenerationsInput: EinsteinPromptTemplateGenerationsInputRepresentation_EinsteinPromptTemplateGenerationsInputRepresentation;
+}

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

@@ -0,0 +1,81 @@
+import { EinsteinLlmGenerationCitationRepresentation as EinsteinLlmGenerationCitationRepresentation_EinsteinLlmGenerationCitationRepresentation } from './EinsteinLlmGenerationCitationRepresentation';
+import { EinsteinPromptTemplateAttachmentRepresentation as EinsteinPromptTemplateAttachmentRepresentation_EinsteinPromptTemplateAttachmentRepresentation } from './EinsteinPromptTemplateAttachmentRepresentation';
+import { EinsteinPromptTemplateGenerationsErrorRepresentation as EinsteinPromptTemplateGenerationsErrorRepresentation_EinsteinPromptTemplateGenerationsErrorRepresentation } from './EinsteinPromptTemplateGenerationsErrorRepresentation';
+import { EinsteinLlmGenerationItemRepresentation as EinsteinLlmGenerationItemRepresentation_EinsteinLlmGenerationItemRepresentation } from './EinsteinLlmGenerationItemRepresentation';
+import { WrappedMap as WrappedMap_WrappedMap } from './WrappedMap';
+import { EinsteinPromptTemplateMaskContentRepresentation as EinsteinPromptTemplateMaskContentRepresentation_EinsteinPromptTemplateMaskContentRepresentation } from './EinsteinPromptTemplateMaskContentRepresentation';
+import { EinsteinPromptTemplateMaskDataRepresentation as EinsteinPromptTemplateMaskDataRepresentation_EinsteinPromptTemplateMaskDataRepresentation } from './EinsteinPromptTemplateMaskDataRepresentation';
+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 = 100;
+export declare const VERSION = "25461f267931be0754b36e2788461191";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    requestId: string;
+}
+export type EinsteinPromptTemplateGenerationsRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialEinsteinPromptTemplateGenerationsRepresentationNormalizedKeyMetadata = 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): EinsteinPromptTemplateGenerationsRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: EinsteinPromptTemplateGenerationsRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: EinsteinPromptTemplateGenerationsRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: EinsteinPromptTemplateGenerationsRepresentation, existing: EinsteinPromptTemplateGenerationsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinPromptTemplateGenerationsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinPromptTemplateGenerationsRepresentationNormalized, incoming: EinsteinPromptTemplateGenerationsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinPromptTemplateGenerationsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output of a einstein llm generations response for given prompt template
+ *
+ * Keys:
+ *    requestId (string): requestId
+ */
+export interface EinsteinPromptTemplateGenerationsRepresentationNormalized {
+    citations?: EinsteinLlmGenerationCitationRepresentation_EinsteinLlmGenerationCitationRepresentation;
+    /** file info of the input files used in generation */
+    fileData?: Array<EinsteinPromptTemplateAttachmentRepresentation_EinsteinPromptTemplateAttachmentRepresentation>;
+    /** generated prompt template generationErrors */
+    generationErrors?: Array<EinsteinPromptTemplateGenerationsErrorRepresentation_EinsteinPromptTemplateGenerationsErrorRepresentation>;
+    /** List of generated text */
+    generations: Array<EinsteinLlmGenerationItemRepresentation_EinsteinLlmGenerationItemRepresentation>;
+    /** merge field information mapping used for annotations in the resolved prompt */
+    mergeFieldInformation?: {
+        [key: string]: unknown;
+    };
+    /** Any provider specific attributes will be included as part of this object */
+    parameters: WrappedMap_WrappedMap | null;
+    /** Prompt used for the generation */
+    prompt: string | null;
+    /** generated prompt template promptTemplateDevName */
+    promptTemplateDevName: string;
+    /** ID of the generation request */
+    requestId: string;
+    /** generated prompt template RequestMessages */
+    requestMessages?: Array<EinsteinPromptTemplateMaskContentRepresentation_EinsteinPromptTemplateMaskContentRepresentation>;
+    /** generated prompt template ResponseMessages */
+    responseMessages?: Array<EinsteinPromptTemplateMaskContentRepresentation_EinsteinPromptTemplateMaskContentRepresentation>;
+    /** generated prompt template slotsMaskingInformation */
+    slotsMaskingInformation?: Array<EinsteinPromptTemplateMaskDataRepresentation_EinsteinPromptTemplateMaskDataRepresentation>;
+}
+/**
+ * Output of a einstein llm generations response for given prompt template
+ *
+ * Keys:
+ *    requestId (string): requestId
+ */
+export interface EinsteinPromptTemplateGenerationsRepresentation {
+    citations?: EinsteinLlmGenerationCitationRepresentation_EinsteinLlmGenerationCitationRepresentation;
+    fileData?: Array<EinsteinPromptTemplateAttachmentRepresentation_EinsteinPromptTemplateAttachmentRepresentation>;
+    generationErrors?: Array<EinsteinPromptTemplateGenerationsErrorRepresentation_EinsteinPromptTemplateGenerationsErrorRepresentation>;
+    generations: Array<EinsteinLlmGenerationItemRepresentation_EinsteinLlmGenerationItemRepresentation>;
+    mergeFieldInformation?: {
+        [key: string]: unknown;
+    };
+    parameters: WrappedMap_WrappedMap | null;
+    prompt: string | null;
+    promptTemplateDevName: string;
+    requestId: string;
+    requestMessages?: Array<EinsteinPromptTemplateMaskContentRepresentation_EinsteinPromptTemplateMaskContentRepresentation>;
+    responseMessages?: Array<EinsteinPromptTemplateMaskContentRepresentation_EinsteinPromptTemplateMaskContentRepresentation>;
+    slotsMaskingInformation?: Array<EinsteinPromptTemplateMaskDataRepresentation_EinsteinPromptTemplateMaskDataRepresentation>;
+}

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

@@ -0,0 +1,35 @@
+import { EinsteinPromptTemplateMaskSettingsRepresentation as EinsteinPromptTemplateMaskSettingsRepresentation_EinsteinPromptTemplateMaskSettingsRepresentation } from './EinsteinPromptTemplateMaskSettingsRepresentation';
+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 = "92ad1abd0e2a60bc36941409cadda7e2";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EinsteinPromptTemplateMaskContentRepresentation, existing: EinsteinPromptTemplateMaskContentRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinPromptTemplateMaskContentRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinPromptTemplateMaskContentRepresentationNormalized, incoming: EinsteinPromptTemplateMaskContentRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinPromptTemplateMaskContentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output of a einstein mask data request and response for given prompt template
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateMaskContentRepresentationNormalized {
+    /** content value */
+    content: string;
+    /** moderationSettings value */
+    moderationSettings?: EinsteinPromptTemplateMaskSettingsRepresentation_EinsteinPromptTemplateMaskSettingsRepresentation | null;
+    /** RoleEnum value */
+    role?: string;
+}
+/**
+ * Output of a einstein mask data request and response for given prompt template
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateMaskContentRepresentation {
+    content: string;
+    moderationSettings?: EinsteinPromptTemplateMaskSettingsRepresentation_EinsteinPromptTemplateMaskSettingsRepresentation | null;
+    role?: string;
+}

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

@@ -0,0 +1,34 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "507a815605f8d30ae9b52b0ec513d25e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EinsteinPromptTemplateMaskDataRepresentation, existing: EinsteinPromptTemplateMaskDataRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinPromptTemplateMaskDataRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinPromptTemplateMaskDataRepresentationNormalized, incoming: EinsteinPromptTemplateMaskDataRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinPromptTemplateMaskDataRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output of a einstein mask data response for given prompt template
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateMaskDataRepresentationNormalized {
+    /** original field value */
+    originalValue: string;
+    /** placeholder value */
+    placeHolder: string;
+    /** recognizers */
+    recognizers: Array<string>;
+}
+/**
+ * Output of a einstein mask data response for given prompt template
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateMaskDataRepresentation {
+    originalValue: string;
+    placeHolder: string;
+    recognizers: Array<string>;
+}

package/dist/es/es2018/types/src/generated/types/EinsteinPromptTemplateMaskSettingsRepresentation.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 = "7c417ce44e4bc05dfcc454e6825590e8";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EinsteinPromptTemplateMaskSettingsRepresentation, existing: EinsteinPromptTemplateMaskSettingsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinPromptTemplateMaskSettingsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinPromptTemplateMaskSettingsRepresentationNormalized, incoming: EinsteinPromptTemplateMaskSettingsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinPromptTemplateMaskSettingsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output of a einstein mask data moderation setting for given prompt template
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateMaskSettingsRepresentationNormalized {
+    /** enable moderation value */
+    enableModeration: boolean;
+}
+/**
+ * Output of a einstein mask data moderation setting for given prompt template
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateMaskSettingsRepresentation {
+    enableModeration: boolean;
+}

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

@@ -0,0 +1,62 @@
+import { WrappedMap as WrappedMap_WrappedMap } from './WrappedMap';
+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 = 100;
+export declare const VERSION = "a90a51578e2fdd7a9741d310bed22b1d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    versionId: string;
+}
+export type EinsteinPromptTemplateRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialEinsteinPromptTemplateRepresentationNormalizedKeyMetadata = 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): EinsteinPromptTemplateRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: EinsteinPromptTemplateRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: EinsteinPromptTemplateRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: EinsteinPromptTemplateRepresentation, existing: EinsteinPromptTemplateRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinPromptTemplateRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinPromptTemplateRepresentationNormalized, incoming: EinsteinPromptTemplateRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinPromptTemplateRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Comprehensive representation for prompt template operations including creation, updates, and activation
+ *
+ * Keys:
+ *    versionId (string): versionId
+ */
+export interface EinsteinPromptTemplateRepresentationNormalized {
+    additionalData?: WrappedMap_WrappedMap;
+    /** Error Messages */
+    errorMessages: Array<string>;
+    /** has warning messages */
+    hasWarning: boolean;
+    /** IsSuccessful */
+    isSuccessful: boolean;
+    /** Status Code of connect api */
+    statusCode?: string;
+    /** Template Id */
+    templateId: string;
+    /** Template Type */
+    templateType?: string;
+    /** Version Id */
+    versionId: string;
+    /** Warning Messages */
+    warningMessages: Array<string>;
+}
+/**
+ * Comprehensive representation for prompt template operations including creation, updates, and activation
+ *
+ * Keys:
+ *    versionId (string): versionId
+ */
+export interface EinsteinPromptTemplateRepresentation {
+    additionalData?: WrappedMap_WrappedMap;
+    errorMessages: Array<string>;
+    hasWarning: boolean;
+    isSuccessful: boolean;
+    statusCode?: string;
+    templateId: string;
+    templateType?: string;
+    versionId: string;
+    warningMessages: Array<string>;
+}

package/dist/es/es2018/types/src/generated/types/EinsteinPromptTemplateSupportedLanguageErrorRepresentation.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 = "b513bbac1672327d8eaaf120660e94b5";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EinsteinPromptTemplateSupportedLanguageErrorRepresentation, existing: EinsteinPromptTemplateSupportedLanguageErrorRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinPromptTemplateSupportedLanguageErrorRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinPromptTemplateSupportedLanguageErrorRepresentationNormalized, incoming: EinsteinPromptTemplateSupportedLanguageErrorRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinPromptTemplateSupportedLanguageErrorRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of an error encountered when returning the Prompt Template Version Supported Languages.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateSupportedLanguageErrorRepresentationNormalized {
+    /** Error message for this error */
+    errorMessage: string;
+    /** Message Code for this error. */
+    messageCode: string;
+}
+/**
+ * Representation of an error encountered when returning the Prompt Template Version Supported Languages.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateSupportedLanguageErrorRepresentation {
+    errorMessage: string;
+    messageCode: string;
+}

package/dist/es/es2018/types/src/generated/types/EinsteinPromptTemplateSupportedLanguageRepresentation.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 = "65a17d345c28eeca91872a73d8ffe9fd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EinsteinPromptTemplateSupportedLanguageRepresentation, existing: EinsteinPromptTemplateSupportedLanguageRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinPromptTemplateSupportedLanguageRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinPromptTemplateSupportedLanguageRepresentationNormalized, incoming: EinsteinPromptTemplateSupportedLanguageRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinPromptTemplateSupportedLanguageRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of a single Prompt Template Version Supported Language
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateSupportedLanguageRepresentationNormalized {
+    /** Language Code */
+    languageCode: string;
+    /** Language Display Name */
+    languageDisplayName: string;
+}
+/**
+ * Representation of a single Prompt Template Version Supported Language
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateSupportedLanguageRepresentation {
+    languageCode: string;
+    languageDisplayName: string;
+}

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

@@ -0,0 +1,43 @@
+import { EinsteinPromptTemplateSupportedLanguageErrorRepresentation as EinsteinPromptTemplateSupportedLanguageErrorRepresentation_EinsteinPromptTemplateSupportedLanguageErrorRepresentation } from './EinsteinPromptTemplateSupportedLanguageErrorRepresentation';
+import { EinsteinPromptTemplateSupportedLanguageRepresentation as EinsteinPromptTemplateSupportedLanguageRepresentation_EinsteinPromptTemplateSupportedLanguageRepresentation } from './EinsteinPromptTemplateSupportedLanguageRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const TTL = 100;
+export declare const VERSION = "c635f260bce9a11f7c3bf31d60f42b53";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EinsteinPromptTemplateVersionOutputLanguagesRepresentation, existing: EinsteinPromptTemplateVersionOutputLanguagesRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinPromptTemplateVersionOutputLanguagesRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinPromptTemplateVersionOutputLanguagesRepresentationNormalized, incoming: EinsteinPromptTemplateVersionOutputLanguagesRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinPromptTemplateVersionOutputLanguagesRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of all supported output languages for a given Prompt Template Version
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateVersionOutputLanguagesRepresentationNormalized {
+    /** Supported Language Errors */
+    errors: Array<EinsteinPromptTemplateSupportedLanguageErrorRepresentation_EinsteinPromptTemplateSupportedLanguageErrorRepresentation>;
+    /** Did this call succeed or not. */
+    isSuccess: boolean;
+    /** Prompt Template Developer Name */
+    promptTemplateDevName: string;
+    /** Supported Languages */
+    supportedLanguages: Array<EinsteinPromptTemplateSupportedLanguageRepresentation_EinsteinPromptTemplateSupportedLanguageRepresentation>;
+    /** Prompt Template Version Id */
+    versionId: string;
+}
+/**
+ * Representation of all supported output languages for a given Prompt Template Version
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinPromptTemplateVersionOutputLanguagesRepresentation {
+    errors: Array<EinsteinPromptTemplateSupportedLanguageErrorRepresentation_EinsteinPromptTemplateSupportedLanguageErrorRepresentation>;
+    isSuccess: boolean;
+    promptTemplateDevName: string;
+    supportedLanguages: Array<EinsteinPromptTemplateSupportedLanguageRepresentation_EinsteinPromptTemplateSupportedLanguageRepresentation>;
+    versionId: string;
+}

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

@@ -0,0 +1,37 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "ad8ac9e0ba41c2d60a8be658ab3fc96b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: PromptTemplateDataProviderDiscoveryInputRepresentation, existing: PromptTemplateDataProviderDiscoveryInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): PromptTemplateDataProviderDiscoveryInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: PromptTemplateDataProviderDiscoveryInputRepresentationNormalized, incoming: PromptTemplateDataProviderDiscoveryInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: PromptTemplateDataProviderDiscoveryInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input for data provider discovery API to find available data providers based on criteria
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PromptTemplateDataProviderDiscoveryInputRepresentationNormalized {
+    /** The expression group name for the data provider */
+    groupName?: string;
+    /** The scoped target for data provider discovery */
+    target?: string;
+    /** List of template input parameters for data provider discovery */
+    templateInputs: Array<unknown>;
+    /** The template type name to filter data providers by */
+    templateTypeName: string;
+}
+/**
+ * Input for data provider discovery API to find available data providers based on criteria
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PromptTemplateDataProviderDiscoveryInputRepresentation {
+    groupName?: string;
+    target?: string;
+    templateInputs: Array<unknown>;
+    templateTypeName: string;
+}

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

@@ -0,0 +1,37 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "87817a2b41f70b94ea53ab2ec7cb5319";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: PromptTemplateDataProviderInputParamRepresentation, existing: PromptTemplateDataProviderInputParamRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): PromptTemplateDataProviderInputParamRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: PromptTemplateDataProviderInputParamRepresentationNormalized, incoming: PromptTemplateDataProviderInputParamRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: PromptTemplateDataProviderInputParamRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents an input parameter for a data provider instance
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PromptTemplateDataProviderInputParamRepresentationNormalized {
+    /** The api name of the input parameter */
+    apiName: string;
+    /** The label of the input parameter */
+    label: string;
+    /** The flag to identify if input is mandatory */
+    required: boolean;
+    /** The data type of the input parameter */
+    type: string;
+}
+/**
+ * Represents an input parameter for a data provider instance
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PromptTemplateDataProviderInputParamRepresentation {
+    apiName: string;
+    label: string;
+    required: boolean;
+    type: string;
+}

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

@@ -0,0 +1,30 @@
+import { PromptTemplateDataProviderInstanceConfigRepresentation as PromptTemplateDataProviderInstanceConfigRepresentation_PromptTemplateDataProviderInstanceConfigRepresentation } from './PromptTemplateDataProviderInstanceConfigRepresentation';
+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, StoreLink as $64$luvio_engine_StoreLink, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const TTL = 300;
+export declare const VERSION = "3a6ecdfe18eb2af8f8f6aaa1a30b194c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: PromptTemplateDataProviderInstanceConfigCollectionRepresentation, existing: PromptTemplateDataProviderInstanceConfigCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): PromptTemplateDataProviderInstanceConfigCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: PromptTemplateDataProviderInstanceConfigCollectionRepresentationNormalized, incoming: PromptTemplateDataProviderInstanceConfigCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: PromptTemplateDataProviderInstanceConfigCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection of data provider instance configurations for a prompt template version
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PromptTemplateDataProviderInstanceConfigCollectionRepresentationNormalized {
+    /** List of data provider instance configurations */
+    dataProviderInstanceConfigs: Array<$64$luvio_engine_StoreLink>;
+}
+/**
+ * Collection of data provider instance configurations for a prompt template version
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PromptTemplateDataProviderInstanceConfigCollectionRepresentation {
+    dataProviderInstanceConfigs: Array<PromptTemplateDataProviderInstanceConfigRepresentation_PromptTemplateDataProviderInstanceConfigRepresentation>;
+}

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

@@ -0,0 +1,38 @@
+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 = "274cf47ad59f25a309f109c720950067";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: PromptTemplateDataProviderInstanceConfigInputRepresentation, existing: PromptTemplateDataProviderInstanceConfigInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): PromptTemplateDataProviderInstanceConfigInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: PromptTemplateDataProviderInstanceConfigInputRepresentationNormalized, incoming: PromptTemplateDataProviderInstanceConfigInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: PromptTemplateDataProviderInstanceConfigInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input for data provider instance configuration generation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PromptTemplateDataProviderInstanceConfigInputRepresentationNormalized {
+    /** Additional parameters for the data provider configuration */
+    additionalParam?: {
+        [key: string]: unknown;
+    };
+    /** The definition of the data provider instance */
+    definition: string;
+    /** The expression group name for the data provider */
+    groupName: string;
+}
+/**
+ * Input for data provider instance configuration generation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface PromptTemplateDataProviderInstanceConfigInputRepresentation {
+    additionalParam?: {
+        [key: string]: unknown;
+    };
+    definition: string;
+    groupName: string;
+}