@salesforce/lds-adapters-cms-authoring 1.100.1

package/dist/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/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/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/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/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/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/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/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/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/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/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/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/types/src/generated/types/ManagedContentDateAndTimeNodeValueRepresentation.d.ts

@@ -0,0 +1,33 @@
+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;
+}

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

@@ -0,0 +1,30 @@
+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;
+}

package/dist/types/src/generated/types/ManagedContentDeploymentCollectionRepresentation.d.ts

@@ -0,0 +1,48 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, ResourceIngest as $64$luvio_engine_ResourceIngest, FragmentSelection as $64$luvio_engine_FragmentSelection, LinkSelection as $64$luvio_engine_LinkSelection, StoreLink as $64$luvio_engine_StoreLink, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+import { ManagedContentDeploymentRepresentation as ManagedContentDeploymentRepresentation_ManagedContentDeploymentRepresentation } from './ManagedContentDeploymentRepresentation';
+export declare const VERSION = "274414b5e987a720ed18e8be6963d63d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDeploymentCollectionRepresentation, existing: ManagedContentDeploymentCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDeploymentCollectionRepresentationNormalized;
+export interface DynamicIngestParams {
+    deployments: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: ManagedContentDeploymentCollectionRepresentation, existing: ManagedContentDeploymentCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => ManagedContentDeploymentCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    deployments?: $64$luvio_engine_LinkSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDeploymentCollectionRepresentationNormalized, incoming: ManagedContentDeploymentCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentDeploymentCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentDeploymentCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * Collection of Deployments
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentCollectionRepresentationNormalized {
+    /** URL to the current page of Manage Content deployment records. */
+    currentPageUrl: string;
+    /** ManagedContentDeployment collection */
+    deployments: Array<$64$luvio_engine_StoreLink>;
+    /** URL to the next page of Manage Content deployment records. */
+    nextPageUrl: string;
+    /** URL to the previous page of Managed Content deployment records. */
+    previousPageUrl: string;
+}
+/**
+ * Collection of Deployments
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentCollectionRepresentation {
+    currentPageUrl: string;
+    deployments: Array<ManagedContentDeploymentRepresentation_ManagedContentDeploymentRepresentation>;
+    nextPageUrl: string;
+    previousPageUrl: string;
+}

package/dist/types/src/generated/types/ManagedContentDeploymentInputRepresentation.d.ts

@@ -0,0 +1,50 @@
+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 = "0f99d9ccf1a20440fa557cc86aea9942";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDeploymentInputRepresentation, existing: ManagedContentDeploymentInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDeploymentInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDeploymentInputRepresentationNormalized, incoming: ManagedContentDeploymentInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentDeploymentInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentDeploymentInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input required for creating a deployment
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentInputRepresentationNormalized {
+    /** [Optional] The target channel to publish content to. */
+    channelIds?: Array<string>;
+    /** [Optional] The contents to publish. Not valid to have both contentIds and variantIds. */
+    contentIds?: Array<string>;
+    /** The content space to publish content from. */
+    contentSpaceId: string;
+    /** Description for deployment. */
+    description?: string;
+    /** [Optional] Execute all staged deployments. */
+    executeStagedDeployments?: boolean;
+    /** [Optional] Include Content References for deployment. */
+    includeContentReferences?: boolean;
+    /** [Optional] Scheduled date for deployment. */
+    scheduledDate?: string;
+    /** [Optional] The variants to publish. Not valid to have both contentIds and variantIds */
+    variantIds?: Array<string>;
+}
+/**
+ * Input required for creating a deployment
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentInputRepresentation {
+    channelIds?: Array<string>;
+    contentIds?: Array<string>;
+    contentSpaceId: string;
+    description?: string;
+    executeStagedDeployments?: boolean;
+    includeContentReferences?: boolean;
+    scheduledDate?: string;
+    variantIds?: Array<string>;
+}