@salesforce/lds-adapters-cms-authoring 0.1.0-dev1

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

@@ -0,0 +1,56 @@
+import { ManagedContentNodeValueRepresentation as ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation } from './ManagedContentNodeValueRepresentation';
+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 = "af8c456537766cfd5c8c55df42f0abb5";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentMediaNodeValueRepresentation, existing: ManagedContentMediaNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentMediaNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentMediaNodeValueRepresentationNormalized, incoming: ManagedContentMediaNodeValueRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentMediaNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content node of media type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentMediaNodeValueRepresentationNormalized extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    /** The alternate text for the managed content node. */
+    altText: string;
+    /** The contentKey of managed content being referenced. */
+    contentKey: string;
+    /** The file name of the managed content node. */
+    fileName: string;
+    /** The media type of the managed content node like Image, Video or Document */
+    mediaType: string;
+    /** The mime type of the managed content node. */
+    mimeType: string;
+    /** The resource url of the managed content node. */
+    resourceUrl: string;
+    /** Media thumbnail url. */
+    thumbnailUrl: string;
+    /** The title of the managed content node. */
+    title: string;
+    /** The unauthenticated url of the managed content node. */
+    unauthenticatedUrl: string;
+    /** The url of the managed content node. */
+    url: string;
+}
+/**
+ * Information about a managed content node of media type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentMediaNodeValueRepresentation extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    altText: string;
+    contentKey: string;
+    fileName: string;
+    mediaType: string;
+    mimeType: string;
+    resourceUrl: string;
+    thumbnailUrl: string;
+    title: string;
+    unauthenticatedUrl: string;
+    url: string;
+}

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

@@ -0,0 +1,50 @@
+import { ManagedContentNodeValueRepresentation as ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation } from './ManagedContentNodeValueRepresentation';
+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 = "50e43b0c09d181a66ca9d58fbe482ccd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentMediaSourceNodeValueRepresentation, existing: ManagedContentMediaSourceNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentMediaSourceNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentMediaSourceNodeValueRepresentationNormalized, incoming: ManagedContentMediaSourceNodeValueRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentMediaSourceNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a source of a managed content media.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentMediaSourceNodeValueRepresentationNormalized extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    /** The file name of the media source. */
+    fileName: string;
+    /** Whether media source is uploaded or referenced via external url. */
+    isExternal: boolean;
+    /** The type of media like Image, Video or Document. */
+    mediaType: string;
+    /** The mime type of the media source. */
+    mimeType: string;
+    /** Reference id of the uploaded media source */
+    referenceId: string;
+    /** The API url to the bytes of the media source. */
+    resourceUrl: string;
+    /** The url to the bytes of the media source for unauthenticated users. */
+    unauthenticatedUrl: string;
+    /** The url to the bytes of the source for authenticated users. */
+    url: string;
+}
+/**
+ * Information about a source of a managed content media.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentMediaSourceNodeValueRepresentation extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    fileName: string;
+    isExternal: boolean;
+    mediaType: string;
+    mimeType: string;
+    referenceId: string;
+    resourceUrl: string;
+    unauthenticatedUrl: string;
+    url: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentNodeTypeRepresentation.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 = "dfeb8fbbc5b04f5e0c137055a0501268";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentNodeTypeRepresentation, existing: ManagedContentNodeTypeRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentNodeTypeRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentNodeTypeRepresentationNormalized, incoming: ManagedContentNodeTypeRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentNodeTypeRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content node type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentNodeTypeRepresentationNormalized {
+    /** The label of the managed content node type. */
+    label: string;
+    /** The developer name of the managed content node type. */
+    name: string;
+    /** The type of the managed content node. */
+    nodeType: string;
+}
+/**
+ * Information about a managed content node type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentNodeTypeRepresentation {
+    label: string;
+    name: string;
+    nodeType: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentNodeValueRepresentation.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 = "f459a0803edcf8950c25232fba362a00";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentNodeValueRepresentation, existing: ManagedContentNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentNodeValueRepresentationNormalized, incoming: ManagedContentNodeValueRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content node.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentNodeValueRepresentationNormalized {
+    /** The type of the managed content node. */
+    nodeType: string;
+}
+/**
+ * Information about a managed content node.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentNodeValueRepresentation {
+    nodeType: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentOrchestratorConfigInputRepresentation.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 = "bd00e76f695bf6185b957c664cbe001c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentOrchestratorConfigInputRepresentation, existing: ManagedContentOrchestratorConfigInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentOrchestratorConfigInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentOrchestratorConfigInputRepresentationNormalized, incoming: ManagedContentOrchestratorConfigInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentOrchestratorConfigInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for Managed Content Orchestrator Config.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentOrchestratorConfigInputRepresentationNormalized {
+    /** List of workflow configs. */
+    workflowConfigs: Array<{}>;
+}
+/**
+ * Input representation for Managed Content Orchestrator Config.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentOrchestratorConfigInputRepresentation {
+    workflowConfigs: Array<{}>;
+}

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

@@ -0,0 +1,28 @@
+import { ManagedContentOrchestratorConfigInputRepresentation as ManagedContentOrchestratorConfigInputRepresentation_ManagedContentOrchestratorConfigInputRepresentation } from './ManagedContentOrchestratorConfigInputRepresentation';
+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 = "d0a24ca8d8f03a05c9fdeae89885b9a1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentOrchestratorConfigInputWrapperRepresentation, existing: ManagedContentOrchestratorConfigInputWrapperRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentOrchestratorConfigInputWrapperRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentOrchestratorConfigInputWrapperRepresentationNormalized, incoming: ManagedContentOrchestratorConfigInputWrapperRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentOrchestratorConfigInputWrapperRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Wrapper around input representation for Managed Content Orchestrator Config.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentOrchestratorConfigInputWrapperRepresentationNormalized {
+    mContentOrchConfigInput: ManagedContentOrchestratorConfigInputRepresentation_ManagedContentOrchestratorConfigInputRepresentation;
+}
+/**
+ * Wrapper around input representation for Managed Content Orchestrator Config.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentOrchestratorConfigInputWrapperRepresentation {
+    mContentOrchConfigInput: ManagedContentOrchestratorConfigInputRepresentation_ManagedContentOrchestratorConfigInputRepresentation;
+}

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

@@ -0,0 +1,48 @@
+import { ManagedContentWorkflowConfigRepresentation as ManagedContentWorkflowConfigRepresentation_ManagedContentWorkflowConfigRepresentation } from './ManagedContentWorkflowConfigRepresentation';
+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, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 100;
+export declare const VERSION = "18ff6463be2b1f8640ca93cf1ecb6f43";
+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 ManagedContentOrchestratorConfigRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentOrchestratorConfigRepresentationNormalizedKeyMetadata = 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): ManagedContentOrchestratorConfigRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentOrchestratorConfigRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentOrchestratorConfigRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentOrchestratorConfigRepresentation, existing: ManagedContentOrchestratorConfigRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentOrchestratorConfigRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentOrchestratorConfigRepresentationNormalized, incoming: ManagedContentOrchestratorConfigRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentOrchestratorConfigRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Details of a Orchestrator Config
+ *
+ * Keys:
+ *    id (string): contentSpaceId
+ */
+export interface ManagedContentOrchestratorConfigRepresentationNormalized {
+    /** Content Space Id */
+    contentSpaceId: string;
+    /** Boolean flag depiciting orchestrator module installation status", */
+    isModuleInstalled: boolean;
+    /** Module FQN */
+    moduleFqn: string;
+    /** List of WorkflowConfigs */
+    workflowConfigs: Array<ManagedContentWorkflowConfigRepresentation_ManagedContentWorkflowConfigRepresentation>;
+}
+/**
+ * Details of a Orchestrator Config
+ *
+ * Keys:
+ *    id (string): contentSpaceId
+ */
+export interface ManagedContentOrchestratorConfigRepresentation {
+    contentSpaceId: string;
+    isModuleInstalled: boolean;
+    moduleFqn: string;
+    workflowConfigs: Array<ManagedContentWorkflowConfigRepresentation_ManagedContentWorkflowConfigRepresentation>;
+}

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

@@ -0,0 +1,30 @@
+import { ManagedContentPreviewRepresentation as ManagedContentPreviewRepresentation_ManagedContentPreviewRepresentation } from './ManagedContentPreviewRepresentation';
+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 = 1000;
+export declare const VERSION = "2ea0d489f57171bd8c65e01f79843327";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentPreviewCollectionRepresentation, existing: ManagedContentPreviewCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentPreviewCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentPreviewCollectionRepresentationNormalized, incoming: ManagedContentPreviewCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentPreviewCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection of Managed Content Previews
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentPreviewCollectionRepresentationNormalized {
+    /** ManagedContentPreview collection */
+    previews: Array<ManagedContentPreviewRepresentation_ManagedContentPreviewRepresentation>;
+}
+/**
+ * Collection of Managed Content Previews
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentPreviewCollectionRepresentation {
+    previews: Array<ManagedContentPreviewRepresentation_ManagedContentPreviewRepresentation>;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentPreviewRepresentation.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 = "2776cb6ca1e69cee658bef8b7dfa629f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentPreviewRepresentation, existing: ManagedContentPreviewRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentPreviewRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentPreviewRepresentationNormalized, incoming: ManagedContentPreviewRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentPreviewRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a Managed Content Preview
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentPreviewRepresentationNormalized {
+    /** ManagedContent channel name */
+    channelName: string | null;
+    /** ManagedContent guestPreviewEndpoint */
+    guestPreviewEndpoint: string | null;
+    /** ManagedContent previewEndpoint */
+    previewEndpoint: string | null;
+}
+/**
+ * Information about a Managed Content Preview
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentPreviewRepresentation {
+    channelName: string | null;
+    guestPreviewEndpoint: string | null;
+    previewEndpoint: string | null;
+}

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

@@ -0,0 +1,39 @@
+import { ManagedContentProviderRepresentation as ManagedContentProviderRepresentation_ManagedContentProviderRepresentation } from './ManagedContentProviderRepresentation';
+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 = 120000;
+export declare const VERSION = "cd77a988fa54277e0b7b7288f4c3f843";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentProviderCollectionRepresentation, existing: ManagedContentProviderCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentProviderCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentProviderCollectionRepresentationNormalized, incoming: ManagedContentProviderCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentProviderCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection of managed content providers.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentProviderCollectionRepresentationNormalized {
+    /** URL to the current page of managed content providers. */
+    currentPageUrl: string | null;
+    /** URL to the next page of managed content providers. */
+    nextPageUrl: string | null;
+    /** Managed content providers for this page. */
+    providers: Array<ManagedContentProviderRepresentation_ManagedContentProviderRepresentation>;
+    /** Total number of managed content providers. */
+    total: number;
+}
+/**
+ * Collection of managed content providers.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentProviderCollectionRepresentation {
+    currentPageUrl: string | null;
+    nextPageUrl: string | null;
+    providers: Array<ManagedContentProviderRepresentation_ManagedContentProviderRepresentation>;
+    total: number;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentProviderInstanceInputRepresentation.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 = "c56159cb14975e0ec7da1a7988b78b53";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentProviderInstanceInputRepresentation, existing: ManagedContentProviderInstanceInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentProviderInstanceInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentProviderInstanceInputRepresentationNormalized, incoming: ManagedContentProviderInstanceInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentProviderInstanceInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for Managed Content Provider Instance.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentProviderInstanceInputRepresentationNormalized {
+    /** Provider Instance Key. */
+    instanceKey: string;
+    /** Boolean flag to indicate the key is default for the provider. */
+    isDefault: boolean;
+    /** Provider Instance Name. */
+    name: string;
+    /** Provider Lightning Component Id. */
+    providerLightningComponentId: string;
+}
+/**
+ * Input representation for Managed Content Provider Instance.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentProviderInstanceInputRepresentation {
+    instanceKey: string;
+    isDefault: boolean;
+    name: string;
+    providerLightningComponentId: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentProviderInstanceRepresentation.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 = "5371a5a2fd4e69439554e23684017c89";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentProviderInstanceRepresentation, existing: ManagedContentProviderInstanceRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentProviderInstanceRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentProviderInstanceRepresentationNormalized, incoming: ManagedContentProviderInstanceRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentProviderInstanceRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content instance provider
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentProviderInstanceRepresentationNormalized {
+    /** The provider instance key */
+    instanceKey: string;
+    /** Whether or not the provider instance is the default one */
+    isDefault: boolean;
+    /** The name of the provider instance */
+    name: string;
+    /** The id of the provider instance */
+    providerInstanceId: string;
+}
+/**
+ * Information about a managed content instance provider
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentProviderInstanceRepresentation {
+    instanceKey: string;
+    isDefault: boolean;
+    name: string;
+    providerInstanceId: string;
+}

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

@@ -0,0 +1,47 @@
+import { ManagedContentProviderInstanceRepresentation as ManagedContentProviderInstanceRepresentation_ManagedContentProviderInstanceRepresentation } from './ManagedContentProviderInstanceRepresentation';
+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 = "b89b54fc329ebfa6827fac717669e2bd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentProviderRepresentation, existing: ManagedContentProviderRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentProviderRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentProviderRepresentationNormalized, incoming: ManagedContentProviderRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentProviderRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content provider
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentProviderRepresentationNormalized {
+    /** The component definition of the picker menu item */
+    componentDefinition: string;
+    /** The icon of the picker menu item */
+    icon: string;
+    /** The label of the picker menu item */
+    label: string;
+    /** The id of the provider */
+    providerId: string;
+    /** The provider instances of the provider */
+    providerInstances: Array<ManagedContentProviderInstanceRepresentation_ManagedContentProviderInstanceRepresentation>;
+    /** The entity id of the picker menu item */
+    providerLightningComponentId: string;
+    /** The type of the picker menu item */
+    type: string;
+}
+/**
+ * Information about a managed content provider
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentProviderRepresentation {
+    componentDefinition: string;
+    icon: string;
+    label: string;
+    providerId: string;
+    providerInstances: Array<ManagedContentProviderInstanceRepresentation_ManagedContentProviderInstanceRepresentation>;
+    providerLightningComponentId: string;
+    type: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentPublishInputRepresentation.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 = "a8f90029e2a4ec62dbd6822b6c1c8551";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentPublishInputRepresentation, existing: ManagedContentPublishInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentPublishInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentPublishInputRepresentationNormalized, incoming: ManagedContentPublishInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentPublishInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input required for publishing content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentPublishInputRepresentationNormalized {
+    /** [Optional] The contents to publish. Either contentIds or variantIds is required. */
+    contentIds?: Array<string>;
+    /** [Optional] Managed Content Space Id */
+    contextContentSpaceId?: string;
+    /** Description for publish Action. */
+    description?: string;
+    /** [Optional] Include Content References for deployment. */
+    includeContentReferences?: boolean;
+    /** [Optional] The variants to publish. Either contentIds or variantIds is required. */
+    variantIds?: Array<string>;
+}
+/**
+ * Input required for publishing content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentPublishInputRepresentation {
+    contentIds?: Array<string>;
+    contextContentSpaceId?: string;
+    description?: string;
+    includeContentReferences?: boolean;
+    variantIds?: Array<string>;
+}

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

@@ -0,0 +1,44 @@
+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, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 100;
+export declare const VERSION = "789bce2e581ff7969982fbf2ffbfd9a5";
+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 ManagedContentPublishOutputRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentPublishOutputRepresentationNormalizedKeyMetadata = 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): ManagedContentPublishOutputRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentPublishOutputRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentPublishOutputRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentPublishOutputRepresentation, existing: ManagedContentPublishOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentPublishOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentPublishOutputRepresentationNormalized, incoming: ManagedContentPublishOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentPublishOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a Publish action
+ *
+ * Keys:
+ *    id (string): deploymentId
+ */
+export interface ManagedContentPublishOutputRepresentationNormalized {
+    /** ManagedContentDeployment Entity Id */
+    deploymentId: string;
+    /** Provided description. */
+    description: string | null;
+    /** Publish Date */
+    publishDate: string | null;
+}
+/**
+ * Information about a Publish action
+ *
+ * Keys:
+ *    id (string): deploymentId
+ */
+export interface ManagedContentPublishOutputRepresentation {
+    deploymentId: string;
+    description: string | null;
+    publishDate: string | null;
+}