@salesforce/lds-adapters-cms-authoring 0.131.0

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

@@ -0,0 +1,47 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "aec62bf8c3772de0c308fedbb06b009c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MCSiteVariantRepresentation, existing: MCSiteVariantRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MCSiteVariantRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MCSiteVariantRepresentationNormalized, incoming: MCSiteVariantRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MCSiteVariantRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MCSiteVariantRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * The variant representation of a content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteVariantRepresentationNormalized {
+    /** body of the variant delivered to a site */
+    body: string;
+    /** language of the variant delivered to a site */
+    language: string;
+    /** Last updated by user id of the variant delivered to a site */
+    lastUpdatedBy: string;
+    /** published date of the variant delivered to a site */
+    publishedDate: string;
+    /** title of the variant delivered to a site */
+    title: string;
+    /** urlname/slug of the variant delivered to a site */
+    urlName: string;
+    /** Variant key of the variant delivered to a site */
+    variantKey: string;
+}
+/**
+ * The variant representation of a content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteVariantRepresentation {
+    body: string;
+    language: string;
+    lastUpdatedBy: string;
+    publishedDate: string;
+    title: string;
+    urlName: string;
+    variantKey: string;
+}

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

@@ -0,0 +1,33 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "c1bd6a5b57f660fa8e662df799b6a53d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MContentBodyRepresentation, existing: MContentBodyRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MContentBodyRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MContentBodyRepresentationNormalized, incoming: MContentBodyRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MContentBodyRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MContentBodyRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content version.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentBodyRepresentationNormalized {
+    /** Content Body. */
+    body: {
+        [key: string]: {};
+    };
+}
+/**
+ * Information about a managed content version.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentBodyRepresentation {
+    body: {
+        [key: string]: {};
+    };
+}

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

@@ -0,0 +1,39 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "d499d07717d35fdeaf42293ba189a2cf";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MContentCollectionMetadataRepresentation, existing: MContentCollectionMetadataRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MContentCollectionMetadataRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MContentCollectionMetadataRepresentationNormalized, incoming: MContentCollectionMetadataRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MContentCollectionMetadataRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MContentCollectionMetadataRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection details.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentCollectionMetadataRepresentationNormalized {
+    /** Decription of the collection schema. */
+    description: string;
+    /** Schema of the collection type. */
+    schema: {
+        [key: string]: {};
+    };
+    /** Title of the collection schema. */
+    title: string;
+}
+/**
+ * Collection details.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentCollectionMetadataRepresentation {
+    description: string;
+    schema: {
+        [key: string]: {};
+    };
+    title: string;
+}

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

@@ -0,0 +1,51 @@
+import { MContentDetailRepresentation as MContentDetailRepresentation_MContentDetailRepresentation } from './MContentDetailRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "753b121c32c64298981f6cc7467c5952";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MContentCollectionRepresentation, existing: MContentCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MContentCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MContentCollectionRepresentationNormalized, incoming: MContentCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MContentCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MContentCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection details.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentCollectionRepresentationNormalized {
+    /** The content key */
+    contentKey: string;
+    /** URL to the current page of collection details. The default is 25 managed content versions per page. */
+    currentPageUrl: string;
+    /** Decription of the collection. */
+    description: string;
+    /** Managed content versions for this page. */
+    items: Array<MContentDetailRepresentation_MContentDetailRepresentation>;
+    /** URL to the next page of managed content versions, The default is 25 managed content versions per page. */
+    nextPageUrl: string;
+    /** Title of the collection. */
+    title: string;
+    /** Total number of versions across all pages. */
+    total: number;
+    /** Type of the collection. */
+    type: string;
+}
+/**
+ * Collection details.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentCollectionRepresentation {
+    contentKey: string;
+    currentPageUrl: string;
+    description: string;
+    items: Array<MContentDetailRepresentation_MContentDetailRepresentation>;
+    nextPageUrl: string;
+    title: string;
+    total: number;
+    type: string;
+}

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

@@ -0,0 +1,31 @@
+import { AbstractMContentRepresentation as AbstractMContentRepresentation_AbstractMContentRepresentation } from './AbstractMContentRepresentation';
+import { MContentBodyRepresentation as MContentBodyRepresentation_MContentBodyRepresentation } from './MContentBodyRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "3ffe7a4bb8484250bbe74eb09ddad007";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MContentDetailRepresentation, existing: MContentDetailRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MContentDetailRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MContentDetailRepresentationNormalized, incoming: MContentDetailRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MContentDetailRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MContentDetailRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Full information about a single content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentDetailRepresentationNormalized extends AbstractMContentRepresentation_AbstractMContentRepresentation {
+    /** Get the content body */
+    contentBody: MContentBodyRepresentation_MContentBodyRepresentation;
+}
+/**
+ * Full information about a single content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentDetailRepresentation extends AbstractMContentRepresentation_AbstractMContentRepresentation {
+    contentBody: MContentBodyRepresentation_MContentBodyRepresentation;
+}

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

@@ -0,0 +1,27 @@
+import { AbstractMContentRepresentation as AbstractMContentRepresentation_AbstractMContentRepresentation } from './AbstractMContentRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "1f038ad49e41c5b6cb0bb30d085ea93c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MContentSummaryRepresentation, existing: MContentSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MContentSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MContentSummaryRepresentationNormalized, incoming: MContentSummaryRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MContentSummaryRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MContentSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Compact information about a content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentSummaryRepresentationNormalized extends AbstractMContentRepresentation_AbstractMContentRepresentation {
+}
+/**
+ * Compact information about a content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentSummaryRepresentation extends AbstractMContentRepresentation_AbstractMContentRepresentation {
+}

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

@@ -0,0 +1,33 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "1c933f2c701f3cb90bf7fecc5a491b9d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentAssociationsInputRep, existing: ManagedContentAssociationsInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentAssociationsInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentAssociationsInputRepNormalized, incoming: ManagedContentAssociationsInputRepNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentAssociationsInputRep): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentAssociationsInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input Representation for associations for managed content. Describes how
+  * a ManagedContent is organized. Examples are the list of topics that are
+  * assigned to a ManagedContent and the folders in which the ManagedContent is placed.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentAssociationsInputRepNormalized {
+    /** The names of topics to associate the Managed Content with. Set to empty to remove all topic associations from the Managed Content. */
+    topics: Array<string>;
+}
+/**
+ * Input Representation for associations for managed content. Describes how
+  * a ManagedContent is organized. Examples are the list of topics that are
+  * assigned to a ManagedContent and the folders in which the ManagedContent is placed.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentAssociationsInputRep {
+    topics: Array<string>;
+}

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

@@ -0,0 +1,30 @@
+import { TopicSummaryRepresentation as TopicSummaryRepresentation_TopicSummaryRepresentation } from './TopicSummaryRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "ca60758bbedefcb798f1d7f89a8b95ca";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentAssociationsRepresentation, existing: ManagedContentAssociationsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentAssociationsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentAssociationsRepresentationNormalized, incoming: ManagedContentAssociationsRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentAssociationsRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentAssociationsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * The Managed Content Associations, e.g. topic associations, describing how this Managed Content is organized and discoverable
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentAssociationsRepresentationNormalized {
+    /** A collection of topics associated with this Managed Content. */
+    topics: Array<TopicSummaryRepresentation_TopicSummaryRepresentation>;
+}
+/**
+ * The Managed Content Associations, e.g. topic associations, describing how this Managed Content is organized and discoverable
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentAssociationsRepresentation {
+    topics: Array<TopicSummaryRepresentation_TopicSummaryRepresentation>;
+}

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

@@ -0,0 +1,33 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "11d9687f9604d5b45e29e349d191c9c9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentBodyInputRep, existing: ManagedContentBodyInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentBodyInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentBodyInputRepNormalized, incoming: ManagedContentBodyInputRepNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentBodyInputRep): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentBodyInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for the body of a managed content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentBodyInputRepNormalized {
+    /** The body of the managed content version. */
+    nodeMap: {
+        [key: string]: {};
+    };
+}
+/**
+ * Input representation for the body of a managed content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentBodyInputRep {
+    nodeMap: {
+        [key: string]: {};
+    };
+}

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

@@ -0,0 +1,35 @@
+import { ManagedContentChannelTargetEntitySummaryRepresentation as ManagedContentChannelTargetEntitySummaryRepresentation_ManagedContentChannelTargetEntitySummaryRepresentation } from './ManagedContentChannelTargetEntitySummaryRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "15cefa027302e75de834408efb308791";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentChannelSummaryRepresentation, existing: ManagedContentChannelSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentChannelSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentChannelSummaryRepresentationNormalized, incoming: ManagedContentChannelSummaryRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentChannelSummaryRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentChannelSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Contextual Information of the channel in managed content delivery api
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChannelSummaryRepresentationNormalized {
+    /** Name of the managed content channel */
+    name: string;
+    /** Resource Url to fetch complete information of the channel */
+    resourceUrl: string;
+    targetEntity: ManagedContentChannelTargetEntitySummaryRepresentation_ManagedContentChannelTargetEntitySummaryRepresentation;
+}
+/**
+ * Contextual Information of the channel in managed content delivery api
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChannelSummaryRepresentation {
+    name: string;
+    resourceUrl: string;
+    targetEntity: ManagedContentChannelTargetEntitySummaryRepresentation_ManagedContentChannelTargetEntitySummaryRepresentation;
+}

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

@@ -0,0 +1,29 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "5822a06dc7aae0f35de02565e442497a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentChannelTargetEntitySummaryRepresentation, existing: ManagedContentChannelTargetEntitySummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentChannelTargetEntitySummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentChannelTargetEntitySummaryRepresentationNormalized, incoming: ManagedContentChannelTargetEntitySummaryRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentChannelTargetEntitySummaryRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentChannelTargetEntitySummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Contextual Information of the channel in managed content delivery api
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChannelTargetEntitySummaryRepresentationNormalized {
+    /** Id of the target entity associated with the channel */
+    id: string;
+}
+/**
+ * Contextual Information of the channel in managed content delivery api
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChannelTargetEntitySummaryRepresentation {
+    id: string;
+}

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

@@ -0,0 +1,35 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "b06fe159fd96d5fee4317f871d4de5ca";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentChildRepresentation, existing: ManagedContentChildRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentChildRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentChildRepresentationNormalized, incoming: ManagedContentChildRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentChildRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentChildRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * The representation of a child managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChildRepresentationNormalized {
+    /** Content key of a Managed Content */
+    contentKey: string;
+    /** Type of a Managed Content */
+    contentType: string;
+    /** Id of a Managed Content */
+    managedContentId: string;
+}
+/**
+ * The representation of a child managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChildRepresentation {
+    contentKey: string;
+    contentType: string;
+    managedContentId: string;
+}

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

@@ -0,0 +1,73 @@
+import { ManagedContentTypeSummaryRepresentation as ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation } from './ManagedContentTypeSummaryRepresentation';
+import { ManagedContentCollectionItemRepresentation as ManagedContentCollectionItemRepresentation_ManagedContentCollectionItemRepresentation } from './ManagedContentCollectionItemRepresentation';
+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 = "eeea454f1268ece5c3e24c986688b876";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    collection_key: string;
+    language: string;
+    version: string;
+}
+export type ManagedContentCollectionDetailRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentCollectionDetailRepresentationNormalizedKeyMetadata = 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): ManagedContentCollectionDetailRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentCollectionDetailRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentCollectionDetailRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentCollectionDetailRepresentation, existing: ManagedContentCollectionDetailRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCollectionDetailRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentCollectionDetailRepresentationNormalized, incoming: ManagedContentCollectionDetailRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentCollectionDetailRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentCollectionDetailRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about collection Items for authoring.
+ *
+ * Keys:
+ *    collection_key (string): collectionKey
+ *    language (string): language
+ *    version (string): versionNumber
+ */
+export interface ManagedContentCollectionDetailRepresentationNormalized {
+    /** The collection key */
+    collectionKey: string;
+    collectionType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    /** The id of the collection */
+    id: string;
+    /** Published Date of the collection. */
+    isPublished: boolean;
+    /** Collection Items for this page. */
+    items: Array<ManagedContentCollectionItemRepresentation_ManagedContentCollectionItemRepresentation>;
+    /** language of the collection. */
+    language: string;
+    /** Title of the collection. */
+    title: string;
+    /** Total number of items in current collection detail page. */
+    total: number;
+    /** URL Name of the collection. */
+    urlName: string;
+    /** The version number of the managed content collection. */
+    versionNumber: string;
+}
+/**
+ * Information about collection Items for authoring.
+ *
+ * Keys:
+ *    collection_key (string): collectionKey
+ *    language (string): language
+ *    version (string): versionNumber
+ */
+export interface ManagedContentCollectionDetailRepresentation {
+    collectionKey: string;
+    collectionType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    id: string;
+    isPublished: boolean;
+    items: Array<ManagedContentCollectionItemRepresentation_ManagedContentCollectionItemRepresentation>;
+    language: string;
+    title: string;
+    total: number;
+    urlName: string;
+    versionNumber: string;
+}

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

@@ -0,0 +1,42 @@
+import { ManagedContentCollectionItemTypeSummaryRepresentation as ManagedContentCollectionItemTypeSummaryRepresentation_ManagedContentCollectionItemTypeSummaryRepresentation } from './ManagedContentCollectionItemTypeSummaryRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "e48874c125059a35740c268f47c641ff";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentCollectionItemRepresentation, existing: ManagedContentCollectionItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCollectionItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentCollectionItemRepresentationNormalized, incoming: ManagedContentCollectionItemRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentCollectionItemRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentCollectionItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Compact information about a content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionItemRepresentationNormalized {
+    /** Get the content body of collection item */
+    body: {
+        [key: string]: unknown;
+    };
+    contentType: ManagedContentCollectionItemTypeSummaryRepresentation_ManagedContentCollectionItemTypeSummaryRepresentation;
+    /** The unique identifier of collection item. */
+    id: string;
+    /** The name or title for collection item */
+    name: string;
+}
+/**
+ * Compact information about a content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionItemRepresentation {
+    body: {
+        [key: string]: unknown;
+    };
+    contentType: ManagedContentCollectionItemTypeSummaryRepresentation_ManagedContentCollectionItemTypeSummaryRepresentation;
+    id: string;
+    name: string;
+}

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

@@ -0,0 +1,32 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "455d12322ac1725bfd56e37d2fc2a4f0";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentCollectionItemTypeSummaryRepresentation, existing: ManagedContentCollectionItemTypeSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCollectionItemTypeSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentCollectionItemTypeSummaryRepresentationNormalized, incoming: ManagedContentCollectionItemTypeSummaryRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentCollectionItemTypeSummaryRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentCollectionItemTypeSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a collection item type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionItemTypeSummaryRepresentationNormalized {
+    /** Fully qualified name of collection item type. */
+    fullyQualifiedName: string;
+    /** Name of collection item type. */
+    name: string;
+}
+/**
+ * Information about a collection item type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionItemTypeSummaryRepresentation {
+    fullyQualifiedName: string;
+    name: string;
+}

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

@@ -0,0 +1,30 @@
+import { ManagedContentRepresentation as ManagedContentRepresentation_ManagedContentRepresentation } from './ManagedContentRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "45cefa762cde4d4011ccb1568def82ae";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentCollectionRepresentation, existing: ManagedContentCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentCollectionRepresentationNormalized, incoming: ManagedContentCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * The output representation of a list of contents
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionRepresentationNormalized {
+    /** List of contents */
+    contents: Array<ManagedContentRepresentation_ManagedContentRepresentation>;
+}
+/**
+ * The output representation of a list of contents
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionRepresentation {
+    contents: Array<ManagedContentRepresentation_ManagedContentRepresentation>;
+}