@salesforce/lds-adapters-cms-authoring 1.100.1

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

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

@@ -0,0 +1,29 @@
+import { ManagedContentExportContentV2JobRequestInputRepresentation as ManagedContentExportContentV2JobRequestInputRepresentation_ManagedContentExportContentV2JobRequestInputRepresentation } from './ManagedContentExportContentV2JobRequestInputRepresentation';
+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 = "6e5f0cca79163cd13e31be08dc95ab03";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentExportContentV2JobRequestInputWrapperRep, existing: ManagedContentExportContentV2JobRequestInputWrapperRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentExportContentV2JobRequestInputWrapperRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentExportContentV2JobRequestInputWrapperRepNormalized, incoming: ManagedContentExportContentV2JobRequestInputWrapperRepNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentExportContentV2JobRequestInputWrapperRep): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentExportContentV2JobRequestInputWrapperRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Wrapper for Input required for export V2 job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentExportContentV2JobRequestInputWrapperRepNormalized {
+    managedContentV2JobRequest: ManagedContentExportContentV2JobRequestInputRepresentation_ManagedContentExportContentV2JobRequestInputRepresentation;
+}
+/**
+ * Wrapper for Input required for export V2 job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentExportContentV2JobRequestInputWrapperRep {
+    managedContentV2JobRequest: ManagedContentExportContentV2JobRequestInputRepresentation_ManagedContentExportContentV2JobRequestInputRepresentation;
+}

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

@@ -0,0 +1,29 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "046edbe6dd6cff9aef9e1e713d743500";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentExportJobItemIdsInputList, existing: ManagedContentExportJobItemIdsInputListNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentExportJobItemIdsInputListNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentExportJobItemIdsInputListNormalized, incoming: ManagedContentExportJobItemIdsInputListNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentExportJobItemIdsInputList): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentExportJobItemIdsInputList, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * ManagedContentExportJobItemIdsInputRepresentation list object
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentExportJobItemIdsInputListNormalized {
+    /** The id value. */
+    ids: Array<string>;
+}
+/**
+ * ManagedContentExportJobItemIdsInputRepresentation list object
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentExportJobItemIdsInputList {
+    ids: Array<string>;
+}

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

@@ -0,0 +1,30 @@
+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, 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 = "fc69f594df895721aef84eca209bc4ca";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentFolderSearchResultRepresentation, existing: ManagedContentFolderSearchResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentFolderSearchResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentFolderSearchResultRepresentationNormalized, incoming: ManagedContentFolderSearchResultRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentFolderSearchResultRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentFolderSearchResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A keyword-based search result for a Managed Content Folder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentFolderSearchResultRepresentationNormalized extends AbstractManagedContentSearchResultRepresentation_AbstractManagedContentSearchResultRepresentation {
+    /** The name of the managed content folder. */
+    name: string;
+}
+/**
+ * A keyword-based search result for a Managed Content Folder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentFolderSearchResultRepresentation extends AbstractManagedContentSearchResultRepresentation_AbstractManagedContentSearchResultRepresentation {
+    name: string;
+}

package/dist/types/src/generated/types/ManagedContentFolderSummaryRepresentation.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 = "aa624c1b1a2e8be8d99839979727e457";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentFolderSummaryRepresentation, existing: ManagedContentFolderSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentFolderSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentFolderSummaryRepresentationNormalized, incoming: ManagedContentFolderSummaryRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentFolderSummaryRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentFolderSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content folder.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentFolderSummaryRepresentationNormalized {
+    /** Id of the managed content folder in the authoring space. */
+    id: string;
+    /** Connect API resource url to get more information about managed content folder. */
+    resourceUrl: string;
+}
+/**
+ * Information about a managed content folder.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentFolderSummaryRepresentation {
+    id: string;
+    resourceUrl: string;
+}

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

@@ -0,0 +1,29 @@
+import { ManagedContentV2JobRequestInputRepresentation as ManagedContentV2JobRequestInputRepresentation_ManagedContentV2JobRequestInputRepresentation } from './ManagedContentV2JobRequestInputRepresentation';
+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 = "55ca9b9fb1689420c62344955686a612";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentImportV2JobRequestInputWrapperRep, existing: ManagedContentImportV2JobRequestInputWrapperRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentImportV2JobRequestInputWrapperRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentImportV2JobRequestInputWrapperRepNormalized, incoming: ManagedContentImportV2JobRequestInputWrapperRepNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentImportV2JobRequestInputWrapperRep): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentImportV2JobRequestInputWrapperRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Wrapper for Input required for import V2 job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentImportV2JobRequestInputWrapperRepNormalized {
+    managedContentV2JobRequest: ManagedContentV2JobRequestInputRepresentation_ManagedContentV2JobRequestInputRepresentation;
+}
+/**
+ * Wrapper for Input required for import V2 job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentImportV2JobRequestInputWrapperRep {
+    managedContentV2JobRequest: ManagedContentV2JobRequestInputRepresentation_ManagedContentV2JobRequestInputRepresentation;
+}