@salesforce/lds-adapters-cms-authoring 0.131.0

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

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

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

@@ -0,0 +1,29 @@
+import { ManagedContentPublishInputRepresentation as ManagedContentPublishInputRepresentation_ManagedContentPublishInputRepresentation } from './ManagedContentPublishInputRepresentation';
+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 = "0bab4b1758be7f3baaf1d2b17b5ac99c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentPublishInputWrapperRepresentation, existing: ManagedContentPublishInputWrapperRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentPublishInputWrapperRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentPublishInputWrapperRepresentationNormalized, incoming: ManagedContentPublishInputWrapperRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentPublishInputWrapperRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentPublishInputWrapperRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Wrapper for Input required for publish managed content or variants
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentPublishInputWrapperRepresentationNormalized {
+    publishInput: ManagedContentPublishInputRepresentation_ManagedContentPublishInputRepresentation;
+}
+/**
+ * Wrapper for Input required for publish managed content or variants
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentPublishInputWrapperRepresentation {
+    publishInput: ManagedContentPublishInputRepresentation_ManagedContentPublishInputRepresentation;
+}

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

@@ -0,0 +1,45 @@
+import { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 100;
+export declare const VERSION = "789bce2e581ff7969982fbf2ffbfd9a5";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    id: string;
+}
+export type ManagedContentPublishOutputRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentPublishOutputRepresentationNormalizedKeyMetadata = Partial<KeyParams> & $64$luvio_engine_NormalizedKeyMetadata;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: KeyParams): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: KeyParams): ManagedContentPublishOutputRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentPublishOutputRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentPublishOutputRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentPublishOutputRepresentation, existing: ManagedContentPublishOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentPublishOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentPublishOutputRepresentationNormalized, incoming: ManagedContentPublishOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentPublishOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentPublishOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a Publish action
+ *
+ * Keys:
+ *    id (string): deploymentId
+ */
+export interface ManagedContentPublishOutputRepresentationNormalized {
+    /** ManagedContentDeployment Entity Id */
+    deploymentId: string;
+    /** Provided description. */
+    description: string | null;
+    /** Publish Date */
+    publishDate: string | null;
+}
+/**
+ * Information about a Publish action
+ *
+ * Keys:
+ *    id (string): deploymentId
+ */
+export interface ManagedContentPublishOutputRepresentation {
+    deploymentId: string;
+    description: string | null;
+    publishDate: string | null;
+}

package/dist/es/es2018/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/es/es2018/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/es/es2018/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/es/es2018/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/es/es2018/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/es/es2018/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/es/es2018/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/es/es2018/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/es/es2018/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/es/es2018/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/es/es2018/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/es/es2018/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;
+}