@salesforce/lds-adapters-cms-delivery 0.131.0

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

@@ -0,0 +1,41 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentUnionSelection as $64$luvio_engine_FragmentUnionSelection, 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 enum DiscriminatorValues {
+    FolderDetail = "FolderDetail",
+    Folder = "Folder"
+}
+export declare const VERSION = "2e617388b0de13d29210032b5dd841bd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: AbstractMCSFolderRepresentation, existing: AbstractMCSFolderRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): AbstractMCSFolderRepresentationNormalized;
+export declare const selectChildren: () => $64$luvio_engine_FragmentUnionSelection;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: AbstractMCSFolderRepresentationNormalized, incoming: AbstractMCSFolderRepresentationNormalized): boolean;
+export declare function deepFreeze(input: AbstractMCSFolderRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare const discriminatorIngest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: AbstractMCSFolderRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Abstract Representation of a CMS Folder i.e. ManagedContentSpaceFolder having only Id, Name, ParentFolderId
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AbstractMCSFolderRepresentationNormalized {
+    /** The ID of the folder - ManagedContentSpaceFolder */
+    id: string;
+    /** The name of the folder */
+    name: string;
+    /** The ID of the folder's parent */
+    parentFolderId: string;
+}
+/**
+ * Abstract Representation of a CMS Folder i.e. ManagedContentSpaceFolder having only Id, Name, ParentFolderId
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AbstractMCSFolderRepresentation {
+    id: string;
+    name: string;
+    parentFolderId: string;
+}

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,38 @@
+import { ManagedContentChannelTargetSummaryRepresentation as ManagedContentChannelTargetSummaryRepresentation_ManagedContentChannelTargetSummaryRepresentation } from './ManagedContentChannelTargetSummaryRepresentation';
+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 = "711706f192bfe4c16392190606f4ea7a";
+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 {
+    /** Domain Url of the org */
+    domainUrl?: string;
+    /** Name of the managed content channel */
+    name: string;
+    /** Resource Url to fetch complete information of the channel */
+    resourceUrl: string;
+    targetSummary?: ManagedContentChannelTargetSummaryRepresentation_ManagedContentChannelTargetSummaryRepresentation;
+}
+/**
+ * Contextual Information of the channel in managed content delivery api
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChannelSummaryRepresentation {
+    domainUrl?: string;
+    name: string;
+    resourceUrl: string;
+    targetSummary?: ManagedContentChannelTargetSummaryRepresentation_ManagedContentChannelTargetSummaryRepresentation;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentChannelTargetSummaryRepresentation.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 = "ab9207f92e6921a049b43696e23dd3ed";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentChannelTargetSummaryRepresentation, existing: ManagedContentChannelTargetSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentChannelTargetSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentChannelTargetSummaryRepresentationNormalized, incoming: ManagedContentChannelTargetSummaryRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentChannelTargetSummaryRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentChannelTargetSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Contextual Information of the channel in managed content delivery api
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChannelTargetSummaryRepresentationNormalized {
+    /** 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 ManagedContentChannelTargetSummaryRepresentation {
+    id: 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/ManagedContentCollectionItemsRepresentation.d.ts

@@ -0,0 +1,59 @@
+import { ManagedContentChannelSummaryRepresentation as ManagedContentChannelSummaryRepresentation_ManagedContentChannelSummaryRepresentation } from './ManagedContentChannelSummaryRepresentation';
+import { ManagedContentTypeSummaryRepresentation as ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation } from './ManagedContentTypeSummaryRepresentation';
+import { ManagedContentCollectionItemRepresentation as ManagedContentCollectionItemRepresentation_ManagedContentCollectionItemRepresentation } from './ManagedContentCollectionItemRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 3600000;
+export declare const VERSION = "f8aeed959e28f0d935539e65aa3e5211";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentCollectionItemsRepresentation, existing: ManagedContentCollectionItemsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCollectionItemsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentCollectionItemsRepresentationNormalized, incoming: ManagedContentCollectionItemsRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentCollectionItemsRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentCollectionItemsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about collection Items.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionItemsRepresentationNormalized {
+    /** The contextual information of the managed content channel */
+    channelInfo: ManagedContentChannelSummaryRepresentation_ManagedContentChannelSummaryRepresentation;
+    /** The collection key */
+    collectionKey: string;
+    collectionType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    /** The id of the collection */
+    id: string;
+    /** Collection Items for this page. */
+    items: Array<ManagedContentCollectionItemRepresentation_ManagedContentCollectionItemRepresentation>;
+    /** language of the collection. */
+    language: string;
+    /** Published Date of the collection. */
+    publishedDate: 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;
+}
+/**
+ * Information about collection Items.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionItemsRepresentation {
+    channelInfo: ManagedContentChannelSummaryRepresentation_ManagedContentChannelSummaryRepresentation;
+    collectionKey: string;
+    collectionType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    id: string;
+    items: Array<ManagedContentCollectionItemRepresentation_ManagedContentCollectionItemRepresentation>;
+    language: string;
+    publishedDate: string;
+    title: string;
+    total: number;
+    urlName: string;
+}

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

@@ -0,0 +1,66 @@
+import { ManagedContentChannelSummaryRepresentation as ManagedContentChannelSummaryRepresentation_ManagedContentChannelSummaryRepresentation } from './ManagedContentChannelSummaryRepresentation';
+import { ManagedContentTypeSummaryRepresentation as ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation } from './ManagedContentTypeSummaryRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 3600000;
+export declare const VERSION = "181754fe91f1eab67546c9f961cedb5f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentCollectionMetadataRepresentation, existing: ManagedContentCollectionMetadataRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCollectionMetadataRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentCollectionMetadataRepresentationNormalized, incoming: ManagedContentCollectionMetadataRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentCollectionMetadataRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentCollectionMetadataRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection Metadata.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionMetadataRepresentationNormalized {
+    /** The contextual information of the channel */
+    channelInfo: ManagedContentChannelSummaryRepresentation_ManagedContentChannelSummaryRepresentation;
+    /** Globally unique identifier of a collection and doesn't change when collection is moved between production and sandbox environments. */
+    collectionKey: string;
+    /** The basic metadata of the collection */
+    collectionMetadata: {
+        [key: string]: unknown;
+    };
+    collectionType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    /** Id of the collection. */
+    id: string;
+    /** The language of the collection. */
+    language: string;
+    /** The last time the collection has been published. */
+    publishedDate: string;
+    /** The expanded type metadata of the collection */
+    schema: {
+        [key: string]: unknown;
+    };
+    /** The title of the collection. */
+    title: string;
+    /** The content url name of the collection. */
+    urlName: string;
+}
+/**
+ * Collection Metadata.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionMetadataRepresentation {
+    channelInfo: ManagedContentChannelSummaryRepresentation_ManagedContentChannelSummaryRepresentation;
+    collectionKey: string;
+    collectionMetadata: {
+        [key: string]: unknown;
+    };
+    collectionType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    id: string;
+    language: string;
+    publishedDate: string;
+    schema: {
+        [key: string]: unknown;
+    };
+    title: string;
+    urlName: 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>;
+}

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

@@ -0,0 +1,34 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "b271dacd24edaebd946f545cf6a610c8";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDateAndTimeNodeValueRepresentation, existing: ManagedContentDateAndTimeNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDateAndTimeNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDateAndTimeNodeValueRepresentationNormalized, incoming: ManagedContentDateAndTimeNodeValueRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentDateAndTimeNodeValueRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentDateAndTimeNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content node of datetime type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDateAndTimeNodeValueRepresentationNormalized extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    /** The DateTime value in UTC of the managed content node. */
+    dateTimeValue: string;
+    /** The TimeZone in which DateTime is authored of the managed content node. */
+    timeZone: string;
+}
+/**
+ * Information about a managed content node of datetime type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDateAndTimeNodeValueRepresentation extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    dateTimeValue: string;
+    timeZone: string;
+    nodeType: 'Date';
+}

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

@@ -0,0 +1,31 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "e6edcbe8357965ca6c5ceb4e782eaf62";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDateNodeValueRepresentation, existing: ManagedContentDateNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDateNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDateNodeValueRepresentationNormalized, incoming: ManagedContentDateNodeValueRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentDateNodeValueRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentDateNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content node of type date.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDateNodeValueRepresentationNormalized extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    /** The date value of the managed content node. */
+    value: string;
+}
+/**
+ * Information about a managed content node of type date.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDateNodeValueRepresentation extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    value: string;
+    nodeType: 'Date';
+}

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

@@ -0,0 +1,33 @@
+import { ManagedContentDetailRepresentation as ManagedContentDetailRepresentation_ManagedContentDetailRepresentation } from './ManagedContentDetailRepresentation';
+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 = "d2bd3b32e6edf2fb85c366b44e0bab7e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDetailCollectionRepresentation, existing: ManagedContentDetailCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDetailCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDetailCollectionRepresentationNormalized, incoming: ManagedContentDetailCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentDetailCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentDetailCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection of ManagedContentDetailCollection
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDetailCollectionRepresentationNormalized {
+    /** Managed Content Details */
+    managedContentRecords: Array<ManagedContentDetailRepresentation_ManagedContentDetailRepresentation>;
+    /** Total count of records */
+    totalItem: number;
+}
+/**
+ * Collection of ManagedContentDetailCollection
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDetailCollectionRepresentation {
+    managedContentRecords: Array<ManagedContentDetailRepresentation_ManagedContentDetailRepresentation>;
+    totalItem: number;
+}

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

@@ -0,0 +1,38 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "34b00f0dce16a33620ec4e3aa3fd117e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDetailRepresentation, existing: ManagedContentDetailRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDetailRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDetailRepresentationNormalized, incoming: ManagedContentDetailRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentDetailRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentDetailRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Details of a Managed Content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDetailRepresentationNormalized {
+    /** Content Key */
+    contentKey: string;
+    /** Id of the Managed Content */
+    managedContentId: string;
+    /** Id Managed Content Space */
+    managedContentSpaceId: string;
+    /** Id of the Managed Content Version */
+    managedContentVersionId: string;
+}
+/**
+ * Details of a Managed Content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDetailRepresentation {
+    contentKey: string;
+    managedContentId: string;
+    managedContentSpaceId: string;
+    managedContentVersionId: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentInputRep.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 = "f7f62279f5c067e9748e1efa728a0ee8";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentInputRep, existing: ManagedContentInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentInputRepNormalized, incoming: ManagedContentInputRepNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentInputRep): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for a managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentInputRepNormalized {
+    /** The published version id of the managed content. */
+    publishedVersionId: string;
+}
+/**
+ * Input representation for a managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentInputRep {
+    publishedVersionId: string;
+}