@salesforce/lds-adapters-analytics-wave 0.1.0-dev1

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

@@ -0,0 +1,48 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+import { SaqlQueryResultsRepresentation as SaqlQueryResultsRepresentation_SaqlQueryResultsRepresentation } from './SaqlQueryResultsRepresentation';
+export declare const VERSION = "7e65611aeb799ba7838db4faa48746ae";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SaqlQueryResultRepresentation, existing: SaqlQueryResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SaqlQueryResultRepresentationNormalized;
+export interface DynamicIngestParams {
+    results: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: SaqlQueryResultRepresentation, existing: SaqlQueryResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => SaqlQueryResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    results?: $64$luvio_engine_LinkSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SaqlQueryResultRepresentationNormalized, incoming: SaqlQueryResultRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SaqlQueryResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * Represents a string of JSON content that will be serialized as-is.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SaqlQueryResultRepresentationNormalized {
+    [key: string]: unknown;
+    action?: string;
+    /** The requested query */
+    query: string;
+    responseId?: string;
+    responseTime?: number;
+    results: $64$luvio_engine_StoreLink;
+}
+/**
+ * Represents a string of JSON content that will be serialized as-is.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SaqlQueryResultRepresentation {
+    [key: string]: unknown;
+    action?: string;
+    query: string;
+    responseId?: string;
+    responseTime?: number;
+    results: SaqlQueryResultsRepresentation_SaqlQueryResultsRepresentation;
+}

package/dist/es/es2018/types/src/generated/types/SaqlQueryResultsRepresentation.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, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "15f0e4c13ee1eb4745d5f40277c286f7";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SaqlQueryResultsRepresentation, existing: SaqlQueryResultsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SaqlQueryResultsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: SaqlQueryResultsRepresentationNormalized, incoming: SaqlQueryResultsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SaqlQueryResultsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents the record and metadata results of a query execution
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SaqlQueryResultsRepresentationNormalized {
+    [key: string]: unknown;
+    /** Metadata about the structure of the result records and the query execution */
+    metadata?: Array<unknown>;
+    /** The result records */
+    records: Array<unknown>;
+}
+/**
+ * Represents the record and metadata results of a query execution
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SaqlQueryResultsRepresentation {
+    [key: string]: unknown;
+    metadata?: Array<unknown>;
+    records: Array<unknown>;
+}

package/dist/es/es2018/types/src/generated/types/ScheduleInputRepresentation.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 = "1bcbd5a297bf47ee4d9b9c2ed58f9979";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ScheduleInputRepresentation, existing: ScheduleInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ScheduleInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ScheduleInputRepresentationNormalized, incoming: ScheduleInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ScheduleInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for specifying a daily schedule on which to execute some type of job.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ScheduleInputRepresentationNormalized {
+    /** Level of subscription for the related job. */
+    notificationLevel?: string;
+    /** When the schedule should be run. */
+    time?: {
+        [key: string]: unknown;
+    };
+    /** The expression defining the events that trigger the scheduling of the target asset. Currently, only accepting scheduling of Dataflows and Recipes as the target asset. */
+    triggerRule?: string;
+}
+/**
+ * Input representation for specifying a daily schedule on which to execute some type of job.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ScheduleInputRepresentation {
+    notificationLevel?: string;
+    time?: {
+        [key: string]: unknown;
+    };
+    triggerRule?: string;
+}

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

@@ -0,0 +1,29 @@
+import { ScheduleInputRepresentation as ScheduleInputRepresentation_ScheduleInputRepresentation } from './ScheduleInputRepresentation';
+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 = "d407b21b3d8741165ba0068d06d66a1d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ScheduleInputWrapperRepresentation, existing: ScheduleInputWrapperRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ScheduleInputWrapperRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ScheduleInputWrapperRepresentationNormalized, incoming: ScheduleInputWrapperRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ScheduleInputWrapperRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Wrapper for schedule input representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ScheduleInputWrapperRepresentationNormalized {
+    /** schedule input representation */
+    schedule: ScheduleInputRepresentation_ScheduleInputRepresentation;
+}
+/**
+ * Wrapper for schedule input representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ScheduleInputWrapperRepresentation {
+    schedule: ScheduleInputRepresentation_ScheduleInputRepresentation;
+}

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

@@ -0,0 +1,65 @@
+import { JobEventCollectionRepresentation as JobEventCollectionRepresentation_JobEventCollectionRepresentation } from './JobEventCollectionRepresentation';
+import { TimeRepresentation as TimeRepresentation_TimeRepresentation } from './TimeRepresentation';
+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, FragmentUnionSelection as $64$luvio_engine_FragmentUnionSelection, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare enum DiscriminatorValues {
+    hourly = "hourly",
+    monthly = "monthly",
+    minutely = "minutely",
+    eventdriven = "eventdriven",
+    weekly = "weekly",
+    monthlyrelative = "monthlyrelative",
+    daily = "daily",
+    none = "none"
+}
+export declare const VERSION = "224eb51518219855b4532b0c87fd4d2c";
+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 ScheduleRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialScheduleRepresentationNormalizedKeyMetadata = 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): ScheduleRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ScheduleRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ScheduleRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ScheduleRepresentation, existing: ScheduleRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ScheduleRepresentationNormalized;
+export declare const selectChildren: () => $64$luvio_engine_FragmentUnionSelection;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ScheduleRepresentationNormalized, incoming: ScheduleRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare const discriminatorIngest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ScheduleRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Schedule on which to execute some type of job
+ *
+ * Keys:
+ *    id (string): assetId
+ */
+export interface ScheduleRepresentationNormalized {
+    /** The 18 character ID of the asset. */
+    assetId: string;
+    /** Schedule event information */
+    events?: JobEventCollectionRepresentation_JobEventCollectionRepresentation;
+    /** Frequency on which this schedule is run. */
+    frequency: string;
+    /** Next scheduled time (in UTC) for this schedule. */
+    nextScheduledDate?: string;
+    /** Email notification level of dataflow associated with this schedule. */
+    notificationLevel?: string;
+    time?: TimeRepresentation_TimeRepresentation;
+}
+/**
+ * Schedule on which to execute some type of job
+ *
+ * Keys:
+ *    id (string): assetId
+ */
+export interface ScheduleRepresentation {
+    assetId: string;
+    events?: JobEventCollectionRepresentation_JobEventCollectionRepresentation;
+    frequency: string;
+    nextScheduledDate?: string;
+    notificationLevel?: string;
+    time?: TimeRepresentation_TimeRepresentation;
+}

package/dist/es/es2018/types/src/generated/types/SchemaFieldFormatSymbolsRepresentation.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 = "4b400b1ce9879971358d57179413e0ea";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SchemaFieldFormatSymbolsRepresentation, existing: SchemaFieldFormatSymbolsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SchemaFieldFormatSymbolsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SchemaFieldFormatSymbolsRepresentationNormalized, incoming: SchemaFieldFormatSymbolsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SchemaFieldFormatSymbolsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of Schema Node Fieldformat symbols
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFieldFormatSymbolsRepresentationNormalized {
+    /** Field currency symbol */
+    currencySymbol?: string;
+    /** Field decimal symbol */
+    decimalSymbol?: string;
+    /** Field grouping symbol */
+    groupingSymbol?: string;
+}
+/**
+ * Representation of Schema Node Fieldformat symbols
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFieldFormatSymbolsRepresentation {
+    currencySymbol?: string;
+    decimalSymbol?: string;
+    groupingSymbol?: string;
+}

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

@@ -0,0 +1,34 @@
+import { SchemaFieldTypePropertiesRepresentation as SchemaFieldTypePropertiesRepresentation_SchemaFieldTypePropertiesRepresentation } from './SchemaFieldTypePropertiesRepresentation';
+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 = "16cfcaeab8cb1bd7d51c7918816340fa";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SchemaFieldNewPropertiesRepresentation, existing: SchemaFieldNewPropertiesRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SchemaFieldNewPropertiesRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SchemaFieldNewPropertiesRepresentationNormalized, incoming: SchemaFieldNewPropertiesRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SchemaFieldNewPropertiesRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of Schema Node New Field Properties
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFieldNewPropertiesRepresentationNormalized {
+    /** Field label */
+    label?: string;
+    /** Field name */
+    name?: string;
+    typeProperties?: SchemaFieldTypePropertiesRepresentation_SchemaFieldTypePropertiesRepresentation;
+}
+/**
+ * Representation of Schema Node New Field Properties
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFieldNewPropertiesRepresentation {
+    label?: string;
+    name?: string;
+    typeProperties?: SchemaFieldTypePropertiesRepresentation_SchemaFieldTypePropertiesRepresentation;
+}

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

@@ -0,0 +1,35 @@
+import { SchemaFieldPropertiesInputRepresentation as SchemaFieldPropertiesInputRepresentation_SchemaFieldPropertiesInputRepresentation } from './SchemaFieldPropertiesInputRepresentation';
+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 = "461cffa00fbecf8dfa92b5a4054a91f6";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SchemaFieldParametersInputRepresentation, existing: SchemaFieldParametersInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SchemaFieldParametersInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SchemaFieldParametersInputRepresentationNormalized, incoming: SchemaFieldParametersInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SchemaFieldParametersInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Schema node field
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFieldParametersInputRepresentationNormalized {
+    /** Value to output on error */
+    errorValue?: string;
+    /** Schema field name */
+    name?: string;
+    /** Field Properties */
+    newProperties?: SchemaFieldPropertiesInputRepresentation_SchemaFieldPropertiesInputRepresentation;
+}
+/**
+ * Schema node field
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFieldParametersInputRepresentation {
+    errorValue?: string;
+    name?: string;
+    newProperties?: SchemaFieldPropertiesInputRepresentation_SchemaFieldPropertiesInputRepresentation;
+}

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

@@ -0,0 +1,34 @@
+import { SchemaTypePropertiesCastInputRepresentation as SchemaTypePropertiesCastInputRepresentation_SchemaTypePropertiesCastInputRepresentation } from './SchemaTypePropertiesCastInputRepresentation';
+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 = "38752deaacb24c479def1a975263f8d0";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SchemaFieldPropertiesInputRepresentation, existing: SchemaFieldPropertiesInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SchemaFieldPropertiesInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SchemaFieldPropertiesInputRepresentationNormalized, incoming: SchemaFieldPropertiesInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SchemaFieldPropertiesInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Common Field Properties
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFieldPropertiesInputRepresentationNormalized {
+    /** Field label */
+    label?: string;
+    /** Field name */
+    name?: string;
+    typeProperties: SchemaTypePropertiesCastInputRepresentation_SchemaTypePropertiesCastInputRepresentation;
+}
+/**
+ * Common Field Properties
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFieldPropertiesInputRepresentation {
+    label?: string;
+    name?: string;
+    typeProperties: SchemaTypePropertiesCastInputRepresentation_SchemaTypePropertiesCastInputRepresentation;
+}

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

@@ -0,0 +1,35 @@
+import { SchemaFieldNewPropertiesRepresentation as SchemaFieldNewPropertiesRepresentation_SchemaFieldNewPropertiesRepresentation } from './SchemaFieldNewPropertiesRepresentation';
+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 = "92323abb76d748a3019e4e1365416d92";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SchemaFieldRepresentation, existing: SchemaFieldRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SchemaFieldRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SchemaFieldRepresentationNormalized, incoming: SchemaFieldRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SchemaFieldRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of Schema Node Field
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFieldRepresentationNormalized {
+    /** Value to output on error */
+    errorValue?: string;
+    /** Field name */
+    name?: string;
+    /** New property values */
+    newProperties?: SchemaFieldNewPropertiesRepresentation_SchemaFieldNewPropertiesRepresentation;
+}
+/**
+ * Representation of Schema Node Field
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFieldRepresentation {
+    errorValue?: string;
+    name?: string;
+    newProperties?: SchemaFieldNewPropertiesRepresentation_SchemaFieldNewPropertiesRepresentation;
+}

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

@@ -0,0 +1,44 @@
+import { SchemaFieldFormatSymbolsRepresentation as SchemaFieldFormatSymbolsRepresentation_SchemaFieldFormatSymbolsRepresentation } from './SchemaFieldFormatSymbolsRepresentation';
+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 = "377c6f08dfa7467ac7708891ffa66b80";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SchemaFieldTypePropertiesRepresentation, existing: SchemaFieldTypePropertiesRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SchemaFieldTypePropertiesRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SchemaFieldTypePropertiesRepresentationNormalized, incoming: SchemaFieldTypePropertiesRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SchemaFieldTypePropertiesRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of Schema Node Field type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFieldTypePropertiesRepresentationNormalized {
+    /** Field format */
+    format?: string;
+    /** Field length */
+    length?: number;
+    /** Field precision */
+    precision?: number;
+    /** Field scale */
+    scale?: number;
+    /** Field symbols */
+    symbols?: SchemaFieldFormatSymbolsRepresentation_SchemaFieldFormatSymbolsRepresentation;
+    /** Field type */
+    type?: string;
+}
+/**
+ * Representation of Schema Node Field type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFieldTypePropertiesRepresentation {
+    format?: string;
+    length?: number;
+    precision?: number;
+    scale?: number;
+    symbols?: SchemaFieldFormatSymbolsRepresentation_SchemaFieldFormatSymbolsRepresentation;
+    type?: string;
+}

package/dist/es/es2018/types/src/generated/types/SchemaFormatSymbolsInputRepresentation.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 = "304c6e6b0ed504af4b895357835c73c3";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SchemaFormatSymbolsInputRepresentation, existing: SchemaFormatSymbolsInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SchemaFormatSymbolsInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SchemaFormatSymbolsInputRepresentationNormalized, incoming: SchemaFormatSymbolsInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SchemaFormatSymbolsInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Format for symbols
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFormatSymbolsInputRepresentationNormalized {
+    /** Currency symbol format */
+    currencySymbol?: string;
+    /** Decimal symbol format */
+    decimalSymbol?: string;
+    /** Grouping symbol format */
+    groupingSymbol?: string;
+}
+/**
+ * Format for symbols
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaFormatSymbolsInputRepresentation {
+    currencySymbol?: string;
+    decimalSymbol?: string;
+    groupingSymbol?: string;
+}

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

@@ -0,0 +1,32 @@
+import { SchemaFieldParametersInputRepresentation as SchemaFieldParametersInputRepresentation_SchemaFieldParametersInputRepresentation } from './SchemaFieldParametersInputRepresentation';
+import { SchemaSliceInputRepresentation as SchemaSliceInputRepresentation_SchemaSliceInputRepresentation } from './SchemaSliceInputRepresentation';
+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 = "e3c9f5b7c112d0caf1dc38890626d918";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SchemaParametersInputRepresentation, existing: SchemaParametersInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SchemaParametersInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SchemaParametersInputRepresentationNormalized, incoming: SchemaParametersInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SchemaParametersInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Schema Node in Recipes
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaParametersInputRepresentationNormalized {
+    /** Schema Fields */
+    fields: Array<SchemaFieldParametersInputRepresentation_SchemaFieldParametersInputRepresentation>;
+    slice?: SchemaSliceInputRepresentation_SchemaSliceInputRepresentation;
+}
+/**
+ * Schema Node in Recipes
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaParametersInputRepresentation {
+    fields: Array<SchemaFieldParametersInputRepresentation_SchemaFieldParametersInputRepresentation>;
+    slice?: SchemaSliceInputRepresentation_SchemaSliceInputRepresentation;
+}

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

@@ -0,0 +1,32 @@
+import { SchemaFieldRepresentation as SchemaFieldRepresentation_SchemaFieldRepresentation } from './SchemaFieldRepresentation';
+import { SchemaSliceRepresentation as SchemaSliceRepresentation_SchemaSliceRepresentation } from './SchemaSliceRepresentation';
+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 = "a813a79459516d968fe9751b4394c686";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SchemaParametersRepresentation, existing: SchemaParametersRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SchemaParametersRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SchemaParametersRepresentationNormalized, incoming: SchemaParametersRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SchemaParametersRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of Schema Node
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaParametersRepresentationNormalized {
+    /** Fields to edit */
+    fields: Array<SchemaFieldRepresentation_SchemaFieldRepresentation>;
+    slice?: SchemaSliceRepresentation_SchemaSliceRepresentation;
+}
+/**
+ * Representation of Schema Node
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaParametersRepresentation {
+    fields: Array<SchemaFieldRepresentation_SchemaFieldRepresentation>;
+    slice?: SchemaSliceRepresentation_SchemaSliceRepresentation;
+}

package/dist/es/es2018/types/src/generated/types/SchemaSliceInputRepresentation.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 = "50c39d2d8cc4c39a641f4b6c13b0a72a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SchemaSliceInputRepresentation, existing: SchemaSliceInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SchemaSliceInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SchemaSliceInputRepresentationNormalized, incoming: SchemaSliceInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SchemaSliceInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Slice definition
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaSliceInputRepresentationNormalized {
+    /** Fields for SELECT or DROP */
+    fields: Array<string>;
+    /** Ignore missing fields */
+    ignoreMissingFields?: boolean;
+    /** Slice mode SELECT or DROP */
+    mode?: string;
+}
+/**
+ * Slice definition
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaSliceInputRepresentation {
+    fields: Array<string>;
+    ignoreMissingFields?: boolean;
+    mode?: string;
+}

package/dist/es/es2018/types/src/generated/types/SchemaSliceRepresentation.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 = "6877d103e3f7485ff0794c5194211af1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: SchemaSliceRepresentation, existing: SchemaSliceRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): SchemaSliceRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: SchemaSliceRepresentationNormalized, incoming: SchemaSliceRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: SchemaSliceRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of Schema Node Slice
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaSliceRepresentationNormalized {
+    /** Fields to select/drop */
+    fields: Array<string>;
+    /** Whether or not to ignore missing fields */
+    ignoreMissingFields?: boolean;
+    /** Select or drop fields */
+    mode?: string;
+}
+/**
+ * Representation of Schema Node Slice
+ *
+ * Keys:
+ *    (none)
+ */
+export interface SchemaSliceRepresentation {
+    fields: Array<string>;
+    ignoreMissingFields?: boolean;
+    mode?: string;
+}