@salesforce/lds-adapters-cms-authoring 1.100.1

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

@@ -0,0 +1,40 @@
+import { AbstractManagedContentReferencedByItemRepresentation as AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation } from './AbstractManagedContentReferencedByItemRepresentation';
+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 = 100;
+export declare const VERSION = "c297f5edbe1b51eadd89e68f176520ba";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByCollectionRepresentation, existing: ManagedContentReferencedByCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentReferencedByCollectionRepresentationNormalized, incoming: ManagedContentReferencedByCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentReferencedByCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection of rof referencing contents
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByCollectionRepresentationNormalized {
+    /** URL to the current page of managed content references. The default is 25 managed content references per page. */
+    currentPageUrl: string;
+    /** URL to the next page of managed content references, The default is 25 managed content references per page. */
+    nextPageUrl: string | null;
+    /** Managed content referenceBy for this page. */
+    referencedBy: Array<AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation>;
+    /** Total number of referencedBy contents across all pages. */
+    total: number;
+}
+/**
+ * Collection of rof referencing contents
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByCollectionRepresentation {
+    currentPageUrl: string;
+    nextPageUrl: string | null;
+    referencedBy: Array<AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation>;
+    total: number;
+}

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

@@ -0,0 +1,38 @@
+import { ManagedContentUserSummaryRepresentation as ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation } from './ManagedContentUserSummaryRepresentation';
+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 = "3306df3b2175592bfe07c027237f2b25";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByContributorItemRepresentation, existing: ManagedContentReferencedByContributorItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByContributorItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentReferencedByContributorItemRepresentationNormalized, incoming: ManagedContentReferencedByContributorItemRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentReferencedByContributorItemRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByContributorItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Representation of the contributor item.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByContributorItemRepresentationNormalized {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** Date when the reference from this contributor item to the managed content was created. */
+    createdDate: string;
+    /** Id of the contributor item */
+    id: string;
+    /** Reference type of the contributor item. */
+    referenceType: string;
+}
+/**
+ * Representation of the contributor item.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByContributorItemRepresentation {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    createdDate: string;
+    id: string;
+    referenceType: string;
+}

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

@@ -0,0 +1,36 @@
+import { AbstractManagedContentReferencedByContributorRepresentation as AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation } from './AbstractManagedContentReferencedByContributorRepresentation';
+import { ManagedContentUserSummaryRepresentation as ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation } from './ManagedContentUserSummaryRepresentation';
+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 = "0c8b8d4551ce47a050dc2f0995be9bdd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByContributorRepresentation, existing: ManagedContentReferencedByContributorRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByContributorRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentReferencedByContributorRepresentationNormalized, incoming: ManagedContentReferencedByContributorRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentReferencedByContributorRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByContributorRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Representation of the contributor
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByContributorRepresentationNormalized extends AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** Date reference created */
+    createdDate: string;
+    /** Reference type of the contributor */
+    referenceType: string;
+}
+/**
+ * Representation of the contributor
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByContributorRepresentation extends AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    createdDate: string;
+    referenceType: string;
+}

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

@@ -0,0 +1,31 @@
+import { AbstractManagedContentReferencedByContributorRepresentation as AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation } from './AbstractManagedContentReferencedByContributorRepresentation';
+import { ManagedContentReferencedByContributorItemRepresentation as ManagedContentReferencedByContributorItemRepresentation_ManagedContentReferencedByContributorItemRepresentation } from './ManagedContentReferencedByContributorItemRepresentation';
+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 = "f138de9d74ceb518fdccbf217e290c43";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByContributorWithContributorItemsRepresentation, existing: ManagedContentReferencedByContributorWithContributorItemsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByContributorWithContributorItemsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentReferencedByContributorWithContributorItemsRepresentationNormalized, incoming: ManagedContentReferencedByContributorWithContributorItemsRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentReferencedByContributorWithContributorItemsRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByContributorWithContributorItemsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Representation of the contributor with contributor items
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByContributorWithContributorItemsRepresentationNormalized extends AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation {
+    /** List of contributor items */
+    contributorItems: Array<ManagedContentReferencedByContributorItemRepresentation_ManagedContentReferencedByContributorItemRepresentation>;
+}
+/**
+ * Representation of the contributor with contributor items
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByContributorWithContributorItemsRepresentation extends AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation {
+    contributorItems: Array<ManagedContentReferencedByContributorItemRepresentation_ManagedContentReferencedByContributorItemRepresentation>;
+}

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

@@ -0,0 +1,27 @@
+import { AbstractManagedContentReferencedByItemRepresentation as AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation } from './AbstractManagedContentReferencedByItemRepresentation';
+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 = "f36c3004a806aefeb01489b4615de4cd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByItemRepresentation, existing: ManagedContentReferencedByItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentReferencedByItemRepresentationNormalized, incoming: ManagedContentReferencedByItemRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentReferencedByItemRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Representation of the contributor
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByItemRepresentationNormalized extends AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation {
+}
+/**
+ * Representation of the contributor
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByItemRepresentation extends AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation {
+}

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

@@ -0,0 +1,33 @@
+import { AbstractManagedContentReferencedByItemRepresentation as AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation } from './AbstractManagedContentReferencedByItemRepresentation';
+import { ManagedContentUserSummaryRepresentation as ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation } from './ManagedContentUserSummaryRepresentation';
+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 = "fcad92443d7f8b4d993415ad501ca358";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByRecordRepresentation, existing: ManagedContentReferencedByRecordRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByRecordRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentReferencedByRecordRepresentationNormalized, incoming: ManagedContentReferencedByRecordRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentReferencedByRecordRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByRecordRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Representation of the referencing entity
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByRecordRepresentationNormalized extends AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** Date when this reference was created. */
+    createdDate: string;
+}
+/**
+ * Representation of the referencing entity
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByRecordRepresentation extends AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    createdDate: string;
+}

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

@@ -0,0 +1,31 @@
+import { AbstractManagedContentReferencedByItemRepresentation as AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation } from './AbstractManagedContentReferencedByItemRepresentation';
+import { AbstractManagedContentReferencedByContributorRepresentation as AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation } from './AbstractManagedContentReferencedByContributorRepresentation';
+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 = "891431f239644f56cd24a166b96b7c29";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByVariantRepresentation, existing: ManagedContentReferencedByVariantRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByVariantRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentReferencedByVariantRepresentationNormalized, incoming: ManagedContentReferencedByVariantRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentReferencedByVariantRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByVariantRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Representation for the managed content variant referencing managed content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByVariantRepresentationNormalized extends AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation {
+    /** Contributor list */
+    contributors: Array<AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation>;
+}
+/**
+ * Representation for the managed content variant referencing managed content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByVariantRepresentation extends AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation {
+    contributors: Array<AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation>;
+}

package/dist/types/src/generated/types/ManagedContentRenditionRepresentation.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, 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 = 1000;
+export declare const VERSION = "98edee4f058ced93570a7b0ce2293672";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentRenditionRepresentation, existing: ManagedContentRenditionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentRenditionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentRenditionRepresentationNormalized, incoming: ManagedContentRenditionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentRenditionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentRenditionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a rendition of CMS content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentRenditionRepresentationNormalized {
+    /** Globally unique identifier of a managed content */
+    contentKey: string;
+    /** The language of the managed content. */
+    language: string;
+    /** Id of the managed content. */
+    managedContentId: string;
+    /** Body containing rendition of content */
+    renditionBody: {
+        [key: string]: unknown;
+    };
+    /** Schema of rendition */
+    renditionSchema: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * Information about a rendition of CMS content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentRenditionRepresentation {
+    contentKey: string;
+    language: string;
+    managedContentId: string;
+    renditionBody: {
+        [key: string]: unknown;
+    };
+    renditionSchema: {
+        [key: string]: unknown;
+    };
+}

package/dist/types/src/generated/types/ManagedContentRepresentation.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 = "19555bba992740d3c21f7a9d093ce989";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentRepresentation, existing: ManagedContentRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentRepresentationNormalized, incoming: ManagedContentRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * The output representation of a managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentRepresentationNormalized {
+    /** Content key of a Managed Content */
+    contentKey: string;
+    /** Content type of a Managed Content */
+    contentType: string;
+}
+/**
+ * The output representation of a managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentRepresentation {
+    contentKey: string;
+    contentType: string;
+}

package/dist/types/src/generated/types/ManagedContentScheduleInputRepresentation.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 = "dbbd49dd8fc38f0eb314f37d95729253";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentScheduleInputRepresentation, existing: ManagedContentScheduleInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentScheduleInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentScheduleInputRepresentationNormalized, incoming: ManagedContentScheduleInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentScheduleInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentScheduleInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input required for creating a scheduled deployment in 232
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentScheduleInputRepresentationNormalized {
+    /** Action can be Publish/Unpublish for deployment */
+    action: string;
+    /** Authoring managed content space id where the deployment will be scheduled */
+    authorSpaceId: string;
+    /** Name of the deployment */
+    description: string;
+    /** Expiry date of the schedule */
+    expireDate: string;
+    /** PublishContentReference will help publish the reference item */
+    publishContentReference: boolean;
+    /** Setting the schedule date for the deployment */
+    scheduleDate: string;
+    /** For unpublish we need to set the versionIds */
+    versionIds: Array<string>;
+}
+/**
+ * Input required for creating a scheduled deployment in 232
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentScheduleInputRepresentation {
+    action: string;
+    authorSpaceId: string;
+    description: string;
+    expireDate: string;
+    publishContentReference: boolean;
+    scheduleDate: string;
+    versionIds: Array<string>;
+}

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

@@ -0,0 +1,39 @@
+import { ManagedContentSearchResultRepresentation as ManagedContentSearchResultRepresentation_ManagedContentSearchResultRepresentation } from './ManagedContentSearchResultRepresentation';
+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 = "572c8571162c9b4e876a5807918f62dc";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSearchResultCollectionRepresentation, existing: ManagedContentSearchResultCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSearchResultCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSearchResultCollectionRepresentationNormalized, incoming: ManagedContentSearchResultCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSearchResultCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSearchResultCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A container of paginated cms keyword-based search result items plus a short search result summary
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultCollectionRepresentationNormalized {
+    /** total search result item count */
+    count: number;
+    /** search result URI */
+    currentPageUri: string;
+    /** an array of search result items */
+    items: Array<ManagedContentSearchResultRepresentation_ManagedContentSearchResultRepresentation>;
+    /** next search result URI */
+    nextPageUri: string;
+}
+/**
+ * A container of paginated cms keyword-based search result items plus a short search result summary
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultCollectionRepresentation {
+    count: number;
+    currentPageUri: string;
+    items: Array<ManagedContentSearchResultRepresentation_ManagedContentSearchResultRepresentation>;
+    nextPageUri: string;
+}

package/dist/types/src/generated/types/ManagedContentSearchResultContentTypeRepresentation.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 = "5f6b2264633c914b484d448513feaa38";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSearchResultContentTypeRepresentation, existing: ManagedContentSearchResultContentTypeRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSearchResultContentTypeRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSearchResultContentTypeRepresentationNormalized, incoming: ManagedContentSearchResultContentTypeRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSearchResultContentTypeRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSearchResultContentTypeRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A keyword-based search result item's content type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultContentTypeRepresentationNormalized {
+    /** managed content type developer name */
+    developerName: string;
+    /** managed content type label */
+    label: string;
+}
+/**
+ * A keyword-based search result item's content type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultContentTypeRepresentation {
+    developerName: string;
+    label: string;
+}

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

@@ -0,0 +1,40 @@
+import { AbstractManagedContentSearchResultRepresentation as AbstractManagedContentSearchResultRepresentation_AbstractManagedContentSearchResultRepresentation } from './AbstractManagedContentSearchResultRepresentation';
+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 = 100;
+export declare const VERSION = "bbcdc04e5d094f6f8048bc2863d86527";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSearchResultItemsCollectionRepresentation, existing: ManagedContentSearchResultItemsCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSearchResultItemsCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentSearchResultItemsCollectionRepresentationNormalized, incoming: ManagedContentSearchResultItemsCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSearchResultItemsCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSearchResultItemsCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A container of paginated CMS keyword-based search result variant and folder items plus a short search result summary
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultItemsCollectionRepresentationNormalized {
+    /** The total count of search results. */
+    count: number;
+    /** The URI for the current page of search results. */
+    currentPageUri: string;
+    /** A list of search result items. */
+    items: Array<AbstractManagedContentSearchResultRepresentation_AbstractManagedContentSearchResultRepresentation>;
+    /** The URI for the next page of search results. */
+    nextPageUri: string;
+}
+/**
+ * A container of paginated CMS keyword-based search result variant and folder items plus a short search result summary
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultItemsCollectionRepresentation {
+    count: number;
+    currentPageUri: string;
+    items: Array<AbstractManagedContentSearchResultRepresentation_AbstractManagedContentSearchResultRepresentation>;
+    nextPageUri: string;
+}

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

@@ -0,0 +1,45 @@
+import { ManagedContentSearchResultContentTypeRepresentation as ManagedContentSearchResultContentTypeRepresentation_ManagedContentSearchResultContentTypeRepresentation } from './ManagedContentSearchResultContentTypeRepresentation';
+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 = "ce64c4bd0832308e5da3e1f327760f21";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSearchResultRepresentation, existing: ManagedContentSearchResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSearchResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSearchResultRepresentationNormalized, incoming: ManagedContentSearchResultRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSearchResultRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSearchResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A keyword-based search result item
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultRepresentationNormalized {
+    /** managed content content key */
+    contentKey: string;
+    /** managed content content type */
+    contentType: ManagedContentSearchResultContentTypeRepresentation_ManagedContentSearchResultContentTypeRepresentation;
+    /** managed content id */
+    id: string;
+    /** managed content published date */
+    publishDate: string;
+    /** managed content title */
+    title: string;
+    /** managed content (version) url name */
+    urlName: string;
+}
+/**
+ * A keyword-based search result item
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultRepresentation {
+    contentKey: string;
+    contentType: ManagedContentSearchResultContentTypeRepresentation_ManagedContentSearchResultContentTypeRepresentation;
+    id: string;
+    publishDate: string;
+    title: string;
+    urlName: string;
+}

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

@@ -0,0 +1,31 @@
+import { ManagedContentSpaceRepresentation as ManagedContentSpaceRepresentation_ManagedContentSpaceRepresentation } from './ManagedContentSpaceRepresentation';
+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 = 100;
+export declare const VERSION = "8bf10074a521799f8a3f77915051deb0";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceCollectionRepresentation, existing: ManagedContentSpaceCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentSpaceCollectionRepresentationNormalized, incoming: ManagedContentSpaceCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSpaceCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection of Managed Content Spaces
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceCollectionRepresentationNormalized {
+    /** ManagedContentSpace records corresponding to the current page. */
+    spaces: Array<ManagedContentSpaceRepresentation_ManagedContentSpaceRepresentation>;
+}
+/**
+ * Collection of Managed Content Spaces
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceCollectionRepresentation {
+    spaces: Array<ManagedContentSpaceRepresentation_ManagedContentSpaceRepresentation>;
+}

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

@@ -0,0 +1,43 @@
+import { AbstractMCSFolderRepresentation as AbstractMCSFolderRepresentation_AbstractMCSFolderRepresentation } from './AbstractMCSFolderRepresentation';
+import { ManagedContentSpaceFolderRepresentation as ManagedContentSpaceFolderRepresentation_ManagedContentSpaceFolderRepresentation } from './ManagedContentSpaceFolderRepresentation';
+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 = "c7f4e18421abf8518331f7134f23db4a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderDetailRepresentation, existing: ManagedContentSpaceFolderDetailRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderDetailRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderDetailRepresentationNormalized, incoming: ManagedContentSpaceFolderDetailRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSpaceFolderDetailRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderDetailRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Detail Representation of a CMS Folder i.e. ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderDetailRepresentationNormalized extends AbstractMCSFolderRepresentation_AbstractMCSFolderRepresentation {
+    /** The User ID of the user who created the folder */
+    createdBy: string;
+    /** The date when the folder was created */
+    createdDate: string;
+    /** The list of the parent folders in the hierarchy - starting from the root upto the direct parent of the folder */
+    folderHierarchy: Array<ManagedContentSpaceFolderRepresentation_ManagedContentSpaceFolderRepresentation>;
+    /** The User ID of the user who last modified the folder */
+    lastModifiedBy: string;
+    /** The date when the folder was last modified */
+    lastModifiedDate: string;
+}
+/**
+ * Detail Representation of a CMS Folder i.e. ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderDetailRepresentation extends AbstractMCSFolderRepresentation_AbstractMCSFolderRepresentation {
+    createdBy: string;
+    createdDate: string;
+    folderHierarchy: Array<ManagedContentSpaceFolderRepresentation_ManagedContentSpaceFolderRepresentation>;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+}