@salesforce/lds-adapters-industries-omnianalytics 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 = "omnianalytics";

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

@@ -0,0 +1,34 @@
+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_getConnectOmniAnalyticsGetAnalyticsLogs_ResourceRequestConfig } from '../resources/getConnectOmniAnalyticsGetAnalyticsLogs';
+import { OmniAnalyticsLogsRepresentation as types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation } from '../types/OmniAnalyticsLogsRepresentation';
+export declare const adapterName = "fetchOmniAnalyticsLogs";
+export declare const fetchOmniAnalyticsLogs_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const fetchOmniAnalyticsLogs_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface FetchOmniAnalyticsLogsConfig {
+    applicationName?: string;
+    componentId?: string;
+    componentType?: string;
+    createdAfter?: string;
+    createdBefore?: string;
+    eventType?: string;
+    pagesize?: number;
+    queryMore?: string;
+}
+export declare const createResourceParams: (config: FetchOmniAnalyticsLogsConfig) => resources_getConnectOmniAnalyticsGetAnalyticsLogs_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsLogsConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsLogsConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<FetchOmniAnalyticsLogsConfig>): adapter$45$utils_Untrusted<FetchOmniAnalyticsLogsConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): FetchOmniAnalyticsLogsConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsLogsConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsLogsConfig): $64$luvio_engine_Snapshot<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsLogsConfig, resourceParams: resources_getConnectOmniAnalyticsGetAnalyticsLogs_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation>): Promise<import("@luvio/engine").FulfilledSnapshot<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation, any>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsLogsConfig, resourceParams: resources_getConnectOmniAnalyticsGetAnalyticsLogs_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsLogsConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: FetchOmniAnalyticsLogsConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation>): $64$luvio_engine_Snapshot<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation, any>;
+export declare const fetchOmniAnalyticsLogsAdapterFactory: $64$luvio_engine_AdapterFactory<FetchOmniAnalyticsLogsConfig, types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation>;

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

@@ -0,0 +1,30 @@
+import { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Fragment as $64$luvio_engine_Fragment, Snapshot as $64$luvio_engine_Snapshot, FetchResponse as $64$luvio_engine_FetchResponse, ErrorResponse as $64$luvio_engine_ErrorResponse, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, CoercedAdapterRequestContext as $64$luvio_engine_CoercedAdapterRequestContext, StoreLookup as $64$luvio_engine_StoreLookup, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { Untrusted as adapter$45$utils_Untrusted, AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig } from './adapter-utils';
+import { ResourceRequestConfig as resources_getConnectOmniAnalyticsAnalyticsMetadata_ResourceRequestConfig } from '../resources/getConnectOmniAnalyticsAnalyticsMetadata';
+import { OmniAnalyticsMetadataRepresentation as types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation } from '../types/OmniAnalyticsMetadataRepresentation';
+export declare const adapterName = "fetchOmniAnalyticsMetadata";
+export declare const fetchOmniAnalyticsMetadata_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const fetchOmniAnalyticsMetadata_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface FetchOmniAnalyticsMetadataConfig {
+    externalTrackingDefName?: string;
+    fetchSettings?: boolean;
+    groupName?: string;
+    isActive?: boolean;
+}
+export declare const createResourceParams: (config: FetchOmniAnalyticsMetadataConfig) => resources_getConnectOmniAnalyticsAnalyticsMetadata_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsMetadataConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsMetadataConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<FetchOmniAnalyticsMetadataConfig>): adapter$45$utils_Untrusted<FetchOmniAnalyticsMetadataConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): FetchOmniAnalyticsMetadataConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsMetadataConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsMetadataConfig): $64$luvio_engine_Snapshot<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsMetadataConfig, resourceParams: resources_getConnectOmniAnalyticsAnalyticsMetadata_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation>): Promise<import("@luvio/engine").FulfilledSnapshot<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation, any>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsMetadataConfig, resourceParams: resources_getConnectOmniAnalyticsAnalyticsMetadata_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: FetchOmniAnalyticsMetadataConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: FetchOmniAnalyticsMetadataConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation>): $64$luvio_engine_Snapshot<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation, any>;
+export declare const fetchOmniAnalyticsMetadataAdapterFactory: $64$luvio_engine_AdapterFactory<FetchOmniAnalyticsMetadataConfig, types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation>;

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

@@ -0,0 +1,19 @@
+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 { ResourceRequestConfig as resources_postConnectOmniAnalyticsAnalyticsLogs_ResourceRequestConfig } from '../resources/postConnectOmniAnalyticsAnalyticsLogs';
+import { OmniAnalyticsLogCreateRepresentation as types_OmniAnalyticsLogCreateRepresentation_OmniAnalyticsLogCreateRepresentation } from '../types/OmniAnalyticsLogCreateRepresentation';
+export declare const adapterName = "storeOmniAnalyticsLogs";
+export declare const storeOmniAnalyticsLogs_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const storeOmniAnalyticsLogs_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface StoreOmniAnalyticsLogsConfig {
+    analyticsLog: string;
+    analyticsLogDate: string;
+    analyticsLogOwnerId: string;
+    componentId: string;
+    eventType: string;
+}
+export declare const createResourceParams: (config: StoreOmniAnalyticsLogsConfig) => resources_postConnectOmniAnalyticsAnalyticsLogs_ResourceRequestConfig;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<StoreOmniAnalyticsLogsConfig>): adapter$45$utils_Untrusted<StoreOmniAnalyticsLogsConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): StoreOmniAnalyticsLogsConfig | null;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: StoreOmniAnalyticsLogsConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<import("@luvio/engine").FulfilledSnapshot<types_OmniAnalyticsLogCreateRepresentation_OmniAnalyticsLogCreateRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_OmniAnalyticsLogCreateRepresentation_OmniAnalyticsLogCreateRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_OmniAnalyticsLogCreateRepresentation_OmniAnalyticsLogCreateRepresentation, any>>;
+export declare const storeOmniAnalyticsLogsAdapterFactory: $64$luvio_engine_AdapterFactory<StoreOmniAnalyticsLogsConfig, types_OmniAnalyticsLogCreateRepresentation_OmniAnalyticsLogCreateRepresentation>;

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

@@ -0,0 +1,3 @@
+export { storeOmniAnalyticsLogsAdapterFactory } from '../adapters/storeOmniAnalyticsLogs';
+export { fetchOmniAnalyticsMetadataAdapterFactory } from '../adapters/fetchOmniAnalyticsMetadata';
+export { fetchOmniAnalyticsLogsAdapterFactory } from '../adapters/fetchOmniAnalyticsLogs';

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

@@ -0,0 +1,6 @@
+declare let fetchOmniAnalyticsLogs: any;
+declare let fetchOmniAnalyticsMetadata: any;
+declare let storeOmniAnalyticsLogs: any;
+declare let fetchOmniAnalyticsLogs_imperative: any;
+declare let fetchOmniAnalyticsMetadata_imperative: any;
+export { fetchOmniAnalyticsLogs, fetchOmniAnalyticsMetadata, storeOmniAnalyticsLogs, fetchOmniAnalyticsLogs_imperative, fetchOmniAnalyticsMetadata_imperative, };

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

@@ -0,0 +1,18 @@
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, FetchResponse as $64$luvio_engine_FetchResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ErrorResponse as $64$luvio_engine_ErrorResponse, ErrorSnapshot as $64$luvio_engine_ErrorSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { OmniAnalyticsMetadataRepresentation as types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation } from '../types/OmniAnalyticsMetadataRepresentation';
+export interface ResourceRequestConfig {
+    queryParams: {
+        externalTrackingDefName?: string;
+        fetchSettings?: boolean;
+        groupName?: string;
+        isActive?: boolean;
+    };
+}
+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_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation, any>;
+export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_OmniAnalyticsMetadataRepresentation_OmniAnalyticsMetadataRepresentation>): $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/getConnectOmniAnalyticsGetAnalyticsLogs.d.ts

@@ -0,0 +1,22 @@
+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 { OmniAnalyticsLogsRepresentation as types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation } from '../types/OmniAnalyticsLogsRepresentation';
+export interface ResourceRequestConfig {
+    queryParams: {
+        applicationName?: string;
+        componentId?: string;
+        componentType?: string;
+        createdAfter?: string;
+        createdBefore?: string;
+        eventType?: string;
+        pagesize?: number;
+        queryMore?: string;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function getResponseCacheKeys(storeKeyMap: any, luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation, any>;
+export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_OmniAnalyticsLogsRepresentation_OmniAnalyticsLogsRepresentation>): $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/postConnectOmniAnalyticsAnalyticsLogs.d.ts

@@ -0,0 +1,16 @@
+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 { OmniAnalyticsLogCreateRepresentation as types_OmniAnalyticsLogCreateRepresentation_OmniAnalyticsLogCreateRepresentation } from '../types/OmniAnalyticsLogCreateRepresentation';
+export interface ResourceRequestConfig {
+    body: {
+        analyticsLog: string;
+        analyticsLogDate: string;
+        analyticsLogOwnerId: string;
+        componentId: string;
+        eventType: 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_OmniAnalyticsLogCreateRepresentation_OmniAnalyticsLogCreateRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_OmniAnalyticsLogCreateRepresentation_OmniAnalyticsLogCreateRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_OmniAnalyticsLogCreateRepresentation_OmniAnalyticsLogCreateRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_OmniAnalyticsLogCreateRepresentation_OmniAnalyticsLogCreateRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_OmniAnalyticsLogCreateRepresentation_OmniAnalyticsLogCreateRepresentation, any>;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

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

@@ -0,0 +1,47 @@
+import { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 10000;
+export declare const VERSION = "3d2e52fd8e2f4a4244b68292d0af7634";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    responseId: string;
+}
+export type OmniAnalyticsLogCreateRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialOmniAnalyticsLogCreateRepresentationNormalizedKeyMetadata = 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): OmniAnalyticsLogCreateRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: OmniAnalyticsLogCreateRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: OmniAnalyticsLogCreateRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: OmniAnalyticsLogCreateRepresentation, existing: OmniAnalyticsLogCreateRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): OmniAnalyticsLogCreateRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: OmniAnalyticsLogCreateRepresentationNormalized, incoming: OmniAnalyticsLogCreateRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: OmniAnalyticsLogCreateRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    responseId (string): responseId
+ */
+export interface OmniAnalyticsLogCreateRepresentationNormalized {
+    /** The platform event publish status if enabled */
+    eventPublishStatus?: string;
+    /** A descriptive status message from external analytics vendors if enabled */
+    externalStatusMesg?: string;
+    /** A 36 character unique identifier for the Omni Analytics log record created for internal events if enabled */
+    internalEventId?: string;
+    /** A descriptive status message from external analytics vendors if enabled */
+    responseId: string;
+}
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    responseId (string): responseId
+ */
+export interface OmniAnalyticsLogCreateRepresentation {
+    eventPublishStatus?: string;
+    externalStatusMesg?: string;
+    internalEventId?: string;
+    responseId: string;
+}

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

@@ -0,0 +1,46 @@
+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 = "71b26da062a33b1206d5b4a578dba540";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: OmniAnalyticsLogDetailRepresentation, existing: OmniAnalyticsLogDetailRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): OmniAnalyticsLogDetailRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: OmniAnalyticsLogDetailRepresentationNormalized, incoming: OmniAnalyticsLogDetailRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: OmniAnalyticsLogDetailRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsLogDetailRepresentationNormalized {
+    /** The date and time at which the Omni Analytics log was generated by the application’s action */
+    applicationLogDate: string;
+    /** Specifies the name of the application. */
+    applicationName: string;
+    /** The record ID within the context of the associated application's component that can be used to retrieve the omni analytics log */
+    componentId: string;
+    /** Specifies the name of the component type. */
+    componentType: string;
+    /** Specifies a component event type, such as a specific application action like a page load or button clicked, of the associated application component. */
+    eventType: string;
+    /** A name to identify the Omni Analytics log record */
+    name: string;
+    /** The contents of the Omni Analytics log as a Json string */
+    omniAnalyticsLog: string;
+}
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsLogDetailRepresentation {
+    applicationLogDate: string;
+    applicationName: string;
+    componentId: string;
+    componentType: string;
+    eventType: string;
+    name: string;
+    omniAnalyticsLog: string;
+}

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

@@ -0,0 +1,40 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "0918506b7b21971c126c8775cd4393e9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: OmniAnalyticsLogInputRepresentation, existing: OmniAnalyticsLogInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): OmniAnalyticsLogInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: OmniAnalyticsLogInputRepresentationNormalized, incoming: OmniAnalyticsLogInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: OmniAnalyticsLogInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsLogInputRepresentationNormalized {
+    /** The contents of the Omni Analytics log as a Json string */
+    analyticsLog: string;
+    /** The date and time at which the Omni Analytics log was generated by the application’s action */
+    analyticsLogDate: string;
+    /** The 18 character Salesforce user id of the user who will own the analytics log. If not specified, will default to the user in whose context the call is being made. */
+    analyticsLogOwnerId: string;
+    /** The record Id of the component like an Omniscript, Card or IntegrationProcedure whose analytics logs are being written */
+    componentId: string;
+    /** The event type generated by the component. This gets stored in the primary filter field in DES for internal events */
+    eventType: string;
+}
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsLogInputRepresentation {
+    analyticsLog: string;
+    analyticsLogDate: string;
+    analyticsLogOwnerId: string;
+    componentId: string;
+    eventType: string;
+}

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

@@ -0,0 +1,33 @@
+import { OmniAnalyticsLogDetailRepresentation as OmniAnalyticsLogDetailRepresentation_OmniAnalyticsLogDetailRepresentation } from './OmniAnalyticsLogDetailRepresentation';
+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 = 10000;
+export declare const VERSION = "4c7a5f813fcd05ae649158a68a2194f4";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: OmniAnalyticsLogsRepresentation, existing: OmniAnalyticsLogsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): OmniAnalyticsLogsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: OmniAnalyticsLogsRepresentationNormalized, incoming: OmniAnalyticsLogsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: OmniAnalyticsLogsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsLogsRepresentationNormalized {
+    /** A list of OmniAnalyticsLogDetailRepresentation */
+    actionLogs: Array<OmniAnalyticsLogDetailRepresentation_OmniAnalyticsLogDetailRepresentation>;
+    /** A string that can be passed to the next call to fetch the next batch of OmniAnalytics Log records */
+    queryMore?: string;
+}
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsLogsRepresentation {
+    actionLogs: Array<OmniAnalyticsLogDetailRepresentation_OmniAnalyticsLogDetailRepresentation>;
+    queryMore?: string;
+}

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

@@ -0,0 +1,46 @@
+import { OmniAnalyticsSettingRepresentation as OmniAnalyticsSettingRepresentation_OmniAnalyticsSettingRepresentation } from './OmniAnalyticsSettingRepresentation';
+import { OmniAnalyticsTrackingComponentRepresentation as OmniAnalyticsTrackingComponentRepresentation_OmniAnalyticsTrackingComponentRepresentation } from './OmniAnalyticsTrackingComponentRepresentation';
+import { OmniAnalyticsTrackingExternalDefRepresentation as OmniAnalyticsTrackingExternalDefRepresentation_OmniAnalyticsTrackingExternalDefRepresentation } from './OmniAnalyticsTrackingExternalDefRepresentation';
+import { OmniAnalyticsTrackingExternalEventDefRepresentation as OmniAnalyticsTrackingExternalEventDefRepresentation_OmniAnalyticsTrackingExternalEventDefRepresentation } from './OmniAnalyticsTrackingExternalEventDefRepresentation';
+import { OmniAnalyticsTrackingGroupRepresentation as OmniAnalyticsTrackingGroupRepresentation_OmniAnalyticsTrackingGroupRepresentation } from './OmniAnalyticsTrackingGroupRepresentation';
+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 = 60000;
+export declare const VERSION = "36cccddb5d7c08dae651feb75fa8c461";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: OmniAnalyticsMetadataRepresentation, existing: OmniAnalyticsMetadataRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): OmniAnalyticsMetadataRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: OmniAnalyticsMetadataRepresentationNormalized, incoming: OmniAnalyticsMetadataRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: OmniAnalyticsMetadataRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsMetadataRepresentationNormalized {
+    /** The list of org wide Omni Analytics settings */
+    omniAnalyticsSettings?: Array<OmniAnalyticsSettingRepresentation_OmniAnalyticsSettingRepresentation>;
+    /** A list of OmniAnalyticsTrackingComponentRepresentation */
+    trackingComponents?: Array<OmniAnalyticsTrackingComponentRepresentation_OmniAnalyticsTrackingComponentRepresentation>;
+    /** A list of OmniAnalyticsTrackingExternalDefRepresentation */
+    trackingExternalDefintions?: Array<OmniAnalyticsTrackingExternalDefRepresentation_OmniAnalyticsTrackingExternalDefRepresentation>;
+    /** A list of OmniAnalyticsTrackingExternalEventDefRepresentation */
+    trackingExternalEventDefintions?: Array<OmniAnalyticsTrackingExternalEventDefRepresentation_OmniAnalyticsTrackingExternalEventDefRepresentation>;
+    /** A list of OmniAnalyticsTrackingGroupRepresentation */
+    trackingGroups?: Array<OmniAnalyticsTrackingGroupRepresentation_OmniAnalyticsTrackingGroupRepresentation>;
+}
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsMetadataRepresentation {
+    omniAnalyticsSettings?: Array<OmniAnalyticsSettingRepresentation_OmniAnalyticsSettingRepresentation>;
+    trackingComponents?: Array<OmniAnalyticsTrackingComponentRepresentation_OmniAnalyticsTrackingComponentRepresentation>;
+    trackingExternalDefintions?: Array<OmniAnalyticsTrackingExternalDefRepresentation_OmniAnalyticsTrackingExternalDefRepresentation>;
+    trackingExternalEventDefintions?: Array<OmniAnalyticsTrackingExternalEventDefRepresentation_OmniAnalyticsTrackingExternalEventDefRepresentation>;
+    trackingGroups?: Array<OmniAnalyticsTrackingGroupRepresentation_OmniAnalyticsTrackingGroupRepresentation>;
+}

package/dist/es/es2018/types/src/generated/types/OmniAnalyticsSettingRepresentation.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 = "0a621a407c2ed4e5cfb104db53f4a29c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: OmniAnalyticsSettingRepresentation, existing: OmniAnalyticsSettingRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): OmniAnalyticsSettingRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: OmniAnalyticsSettingRepresentationNormalized, incoming: OmniAnalyticsSettingRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: OmniAnalyticsSettingRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsSettingRepresentationNormalized {
+    /** Name of the Omni Analytics setting */
+    name: string;
+    /** Value of the setting */
+    value?: string;
+}
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsSettingRepresentation {
+    name: string;
+    value?: string;
+}

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

@@ -0,0 +1,46 @@
+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 = "123d2efc846c30a861e29585f92e2b69";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: OmniAnalyticsTrackingComponentRepresentation, existing: OmniAnalyticsTrackingComponentRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): OmniAnalyticsTrackingComponentRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: OmniAnalyticsTrackingComponentRepresentationNormalized, incoming: OmniAnalyticsTrackingComponentRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: OmniAnalyticsTrackingComponentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsTrackingComponentRepresentationNormalized {
+    /** The 18 character Salesforce record Identifier of the associated actual component like an Omniscript or Flexcard */
+    componentIdentifier: string;
+    /** Specifies the type of component being tracked, for example, OmniScript or FlexCard. */
+    componentType?: string;
+    /** The version of the component that is being tracked. */
+    componentVersion: string;
+    /** The 18 character Salesforce record Identifier */
+    identifier: string;
+    /** A unique name for the tracking component definition. */
+    name: string;
+    /** The parent tracking group definition identifier associated with tracking component definition. */
+    omniTrackingCompGroupId?: string;
+    /** A UUID generated internally by Salesforce to uniquely identify a record across all orgs. */
+    omniTrackingComponentDefKey?: string;
+}
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsTrackingComponentRepresentation {
+    componentIdentifier: string;
+    componentType?: string;
+    componentVersion: string;
+    identifier: string;
+    name: string;
+    omniTrackingCompGroupId?: string;
+    omniTrackingComponentDefKey?: string;
+}

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

@@ -0,0 +1,46 @@
+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 = "c51c45397ac9228be417844ecc8f870f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: OmniAnalyticsTrackingExternalDefRepresentation, existing: OmniAnalyticsTrackingExternalDefRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): OmniAnalyticsTrackingExternalDefRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: OmniAnalyticsTrackingExternalDefRepresentationNormalized, incoming: OmniAnalyticsTrackingExternalDefRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: OmniAnalyticsTrackingExternalDefRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsTrackingExternalDefRepresentationNormalized {
+    /** Description of the external tracking configuration */
+    description: string;
+    /** The 18 character Salesforce record Identifier */
+    identifier: string;
+    /** Indicates whether the External tracking configuration is active (true) or not (false). The default value is true. */
+    isActive?: string;
+    /** The unique name for the External tracking configuration. */
+    name: string;
+    /** A UUID generated internally by Salesforce to uniquely identify a record across all orgs. */
+    omniExtTrackingDefKey: string;
+    /** JSON format containing information about an external service, such as the API call and input parameter names. */
+    trackingFrameworkInformation?: string;
+    /** The external tracking service provider doing the tracking. Google is an example of an external tracking service provider that can consume Omni Analytics data. */
+    trackingServiceProvider?: string;
+}
+/**
+ * Mock Description
+ *
+ * Keys:
+ *    (none)
+ */
+export interface OmniAnalyticsTrackingExternalDefRepresentation {
+    description: string;
+    identifier: string;
+    isActive?: string;
+    name: string;
+    omniExtTrackingDefKey: string;
+    trackingFrameworkInformation?: string;
+    trackingServiceProvider?: string;
+}