@salesforce/lds-adapters-cms-authoring 0.131.0

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

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

@@ -0,0 +1,29 @@
+import { ManagedContentDeploymentInputRepresentation as ManagedContentDeploymentInputRepresentation_ManagedContentDeploymentInputRepresentation } from './ManagedContentDeploymentInputRepresentation';
+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 = "563d3788f6061c3eceebb9d0127e010c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDeploymentInputWrapperRepresentation, existing: ManagedContentDeploymentInputWrapperRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDeploymentInputWrapperRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDeploymentInputWrapperRepresentationNormalized, incoming: ManagedContentDeploymentInputWrapperRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentDeploymentInputWrapperRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentDeploymentInputWrapperRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * wrapper for Input required for creating a deployment
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentInputWrapperRepresentationNormalized {
+    DeploymentInput: ManagedContentDeploymentInputRepresentation_ManagedContentDeploymentInputRepresentation;
+}
+/**
+ * wrapper for Input required for creating a deployment
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentInputWrapperRepresentation {
+    DeploymentInput: ManagedContentDeploymentInputRepresentation_ManagedContentDeploymentInputRepresentation;
+}

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

@@ -0,0 +1,41 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, 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 = "47c74b65bca333078bb7bf037017e86b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDeploymentItemRepresentation, existing: ManagedContentDeploymentItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDeploymentItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDeploymentItemRepresentationNormalized, incoming: ManagedContentDeploymentItemRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentDeploymentItemRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentDeploymentItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a deploymentItem
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentItemRepresentationNormalized {
+    /** Action for the ITEM */
+    action: string;
+    /** ManagedContentDeployment Entity Id */
+    deploymentId: string;
+    /** ManagedContentDeploymentItem Entity Id */
+    deploymentItemId: string;
+    /** Snapshot Entity Id */
+    snapshotId: string;
+    /** Target Entity Id */
+    targetId: string | null;
+}
+/**
+ * Information about a deploymentItem
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentItemRepresentation {
+    action: string;
+    deploymentId: string;
+    deploymentItemId: string;
+    snapshotId: string;
+    targetId: string | null;
+}

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

@@ -0,0 +1,61 @@
+import { ManagedContentDeploymentItemRepresentation as ManagedContentDeploymentItemRepresentation_ManagedContentDeploymentItemRepresentation } from './ManagedContentDeploymentItemRepresentation';
+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 = 1000;
+export declare const VERSION = "ca653daea9600118e6167b9b4ff4d07c";
+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 ManagedContentDeploymentRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentDeploymentRepresentationNormalizedKeyMetadata = 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): ManagedContentDeploymentRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentDeploymentRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentDeploymentRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentDeploymentRepresentation, existing: ManagedContentDeploymentRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDeploymentRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentDeploymentRepresentationNormalized, incoming: ManagedContentDeploymentRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentDeploymentRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentDeploymentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a Deployment
+ *
+ * Keys:
+ *    id (string): deploymentId
+ */
+export interface ManagedContentDeploymentRepresentationNormalized {
+    /** ManagedContentDeployment record creator user Id */
+    createdBy: string | null;
+    /** ManagedContentDeployment Description */
+    deploymentDescription: string | null;
+    /** ManagedContentDeployment Entity Id */
+    deploymentId: string;
+    /** ManagedContentDeploymentItem list */
+    deploymentItems: Array<ManagedContentDeploymentItemRepresentation_ManagedContentDeploymentItemRepresentation>;
+    /** ManagedContentDeployment Name */
+    deploymentName: string | null;
+    /** ManagedContentDeployment Status */
+    deploymentStatus: string | null;
+    /** ManagedContentDeployment record Last Modified user Id */
+    lastModifiedBy: string | null;
+    /** ManagedContentDeployment Scheduled Date */
+    scheduledDate: string | null;
+}
+/**
+ * Information about a Deployment
+ *
+ * Keys:
+ *    id (string): deploymentId
+ */
+export interface ManagedContentDeploymentRepresentation {
+    createdBy: string | null;
+    deploymentDescription: string | null;
+    deploymentId: string;
+    deploymentItems: Array<ManagedContentDeploymentItemRepresentation_ManagedContentDeploymentItemRepresentation>;
+    deploymentName: string | null;
+    deploymentStatus: string | null;
+    lastModifiedBy: string | null;
+    scheduledDate: string | null;
+}

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

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

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

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

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

@@ -0,0 +1,58 @@
+import { ManagedContentChannelSummaryRepresentation as ManagedContentChannelSummaryRepresentation_ManagedContentChannelSummaryRepresentation } from './ManagedContentChannelSummaryRepresentation';
+import { ManagedContentTypeSummaryRepresentation as ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation } from './ManagedContentTypeSummaryRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, 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 = "234445bd88d8688710f0d9c09093e1e1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDocumentDeliveryRepresentation, existing: ManagedContentDocumentDeliveryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDocumentDeliveryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDocumentDeliveryRepresentationNormalized, incoming: ManagedContentDocumentDeliveryRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentDocumentDeliveryRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentDocumentDeliveryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content in delivery scope
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDocumentDeliveryRepresentationNormalized {
+    /** The contextual information of the managed content channel */
+    channelInfo: ManagedContentChannelSummaryRepresentation_ManagedContentChannelSummaryRepresentation;
+    /** Body contains fields defined in the managed content type schema of this managed content. */
+    contentBody: {
+        [key: string]: {};
+    };
+    /** Globally unique identifier of a managed content and doesn't change when managed content is moved between production and sandbox environments. */
+    contentKey: string;
+    contentType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    /** The language of the managed content. */
+    language: string;
+    /** Id of the managed content. */
+    managedContentId: string;
+    /** The last time the managed content has been published. */
+    publishedDate: string;
+    /** The title of the managed content. */
+    title: string;
+    /** The content url name of the managed content. */
+    urlName: string;
+}
+/**
+ * Information about a managed content in delivery scope
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDocumentDeliveryRepresentation {
+    channelInfo: ManagedContentChannelSummaryRepresentation_ManagedContentChannelSummaryRepresentation;
+    contentBody: {
+        [key: string]: {};
+    };
+    contentKey: string;
+    contentType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    language: string;
+    managedContentId: string;
+    publishedDate: string;
+    title: string;
+    urlName: string;
+}

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

@@ -0,0 +1,103 @@
+import { ManagedContentSpaceSummaryRepresentation as ManagedContentSpaceSummaryRepresentation_ManagedContentSpaceSummaryRepresentation } from './ManagedContentSpaceSummaryRepresentation';
+import { ManagedContentTypeSummaryRepresentation as ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation } from './ManagedContentTypeSummaryRepresentation';
+import { ManagedContentUserSummaryRepresentation as ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation } from './ManagedContentUserSummaryRepresentation';
+import { ManagedContentFolderSummaryRepresentation as ManagedContentFolderSummaryRepresentation_ManagedContentFolderSummaryRepresentation } from './ManagedContentFolderSummaryRepresentation';
+import { ManagedContentVariantStatusRepresentation as ManagedContentVariantStatusRepresentation_ManagedContentVariantStatusRepresentation } from './ManagedContentVariantStatusRepresentation';
+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 = "c04d826180efa7be6ad6764b5928469e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    content_key: string;
+    language: string;
+    version: string;
+}
+export type ManagedContentDocumentRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentDocumentRepresentationNormalizedKeyMetadata = 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): ManagedContentDocumentRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentDocumentRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentDocumentRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentDocumentRepresentation, existing: ManagedContentDocumentRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDocumentRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentDocumentRepresentationNormalized, incoming: ManagedContentDocumentRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentDocumentRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentDocumentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content in authoring space.
+ *
+ * Keys:
+ *    content_key (string): contentKey
+ *    language (string): language
+ *    version (string): version
+ */
+export interface ManagedContentDocumentRepresentationNormalized {
+    /** Body contains fields defined in the managed content type schema of this managed content. */
+    contentBody: {
+        [key: string]: unknown;
+    };
+    /** Globally unique identifier of a managed content and doesn't change when managed content is moved between production and sandbox environments. */
+    contentKey: string;
+    contentSpace: ManagedContentSpaceSummaryRepresentation_ManagedContentSpaceSummaryRepresentation;
+    contentType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** The created date of the managed content. */
+    createdDate: string;
+    folder: ManagedContentFolderSummaryRepresentation_ManagedContentFolderSummaryRepresentation;
+    /** Is managed content variant published to any channel. */
+    isPublished: boolean;
+    /** The language of the managed content. */
+    language: string;
+    lastModifiedBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** The last time the managed content has been modified. */
+    lastModifiedDate: string;
+    /** Id of the managed content in authoring space. */
+    managedContentId: string;
+    /** The managed content variant in the authoring space. */
+    managedContentVariantId: string;
+    /** Version id of the managed content version. */
+    managedContentVersionId: string;
+    /** The status of the managed content variant. */
+    status?: ManagedContentVariantStatusRepresentation_ManagedContentVariantStatusRepresentation | null;
+    /** The title of the managed content. */
+    title: string;
+    /** The content url name of the managed content. */
+    urlName: string;
+    /** This is computed property that contains either v1 version id or v2 version number. It is not returned from the server and computed on the client side. */
+    version: string;
+    /** The version number of the managed content. */
+    versionNumber: string | null;
+}
+/**
+ * Information about a managed content in authoring space.
+ *
+ * Keys:
+ *    content_key (string): contentKey
+ *    language (string): language
+ *    version (string): version
+ */
+export interface ManagedContentDocumentRepresentation {
+    contentBody: {
+        [key: string]: unknown;
+    };
+    contentKey: string;
+    contentSpace: ManagedContentSpaceSummaryRepresentation_ManagedContentSpaceSummaryRepresentation;
+    contentType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    createdDate: string;
+    folder: ManagedContentFolderSummaryRepresentation_ManagedContentFolderSummaryRepresentation;
+    isPublished: boolean;
+    language: string;
+    lastModifiedBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    lastModifiedDate: string;
+    managedContentId: string;
+    managedContentVariantId: string;
+    managedContentVersionId: string;
+    status?: ManagedContentVariantStatusRepresentation_ManagedContentVariantStatusRepresentation | null;
+    title: string;
+    urlName: string;
+    version: string;
+    versionNumber: string | null;
+}

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

@@ -0,0 +1,44 @@
+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 = "8c94177fbdf2599b6b405eb2b6ae6e83";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentExportContentJobRequestInputRepresentation, existing: ManagedContentExportContentJobRequestInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentExportContentJobRequestInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentExportContentJobRequestInputRepresentationNormalized, incoming: ManagedContentExportContentJobRequestInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentExportContentJobRequestInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentExportContentJobRequestInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for creating a ManagedContent export job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentExportContentJobRequestInputRepresentationNormalized {
+    /** Managed Content Space Id */
+    contentSpaceId: string;
+    /** Collection of managed Content folder Ids */
+    folderIds: Array<string>;
+    /** The indicator to export the referenced content */
+    includeReferenceContent: boolean;
+    /** Collection of managed Content Ids */
+    managedContentIds: Array<string>;
+    /** Managed Content Export Job Name */
+    name: string;
+    /** Parent FolderId of Managed Content Export data */
+    parentFolderId: string;
+}
+/**
+ * Input representation for creating a ManagedContent export job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentExportContentJobRequestInputRepresentation {
+    contentSpaceId: string;
+    folderIds: Array<string>;
+    includeReferenceContent: boolean;
+    managedContentIds: Array<string>;
+    name: string;
+    parentFolderId: string;
+}

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

@@ -0,0 +1,41 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, 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 = "2a2b3501bf5b92f3387521fd27c6b978";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentExportContentV2JobRequestInputRepresentation, existing: ManagedContentExportContentV2JobRequestInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentExportContentV2JobRequestInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentExportContentV2JobRequestInputRepresentationNormalized, incoming: ManagedContentExportContentV2JobRequestInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentExportContentV2JobRequestInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentExportContentV2JobRequestInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for creating a ManagedContent export job 2.0
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentExportContentV2JobRequestInputRepresentationNormalized {
+    /** Collection of managed Content folder Ids */
+    folderIds: Array<string>;
+    /** The indicator to export the referenced content */
+    includeReferenceContent: boolean;
+    /** The indicator to export the referenced content */
+    includeTranslations: boolean;
+    /** Collection of managed Content Ids */
+    managedContentIds: Array<string>;
+    /** Managed Content Export Job Name */
+    name: string;
+}
+/**
+ * Input representation for creating a ManagedContent export job 2.0
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentExportContentV2JobRequestInputRepresentation {
+    folderIds: Array<string>;
+    includeReferenceContent: boolean;
+    includeTranslations: boolean;
+    managedContentIds: Array<string>;
+    name: string;
+}