@salesforce/lds-adapters-cms-authoring 0.131.0

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

package/dist/es/es2018/types/src/generated/types/ManagedContentInputRep.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 = "f1086fa805d3e9f86b3a53f2b0b39eda";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentInputRep, existing: ManagedContentInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentInputRepNormalized, incoming: ManagedContentInputRepNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentInputRep): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for a managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentInputRepNormalized {
+    /** The published status the user wants to patch the latest version the content to */
+    connectManagedContentStatusEnum: string;
+    /** The published version id of the managed content. */
+    publishedVersionId: string;
+}
+/**
+ * Input representation for a managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentInputRep {
+    connectManagedContentStatusEnum: string;
+    publishedVersionId: string;
+}

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

@@ -0,0 +1,45 @@
+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 = "38bdb1d63a177f72c6bc6e84871f1ba1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentInputRepresentation, existing: ManagedContentInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentInputRepresentationNormalized, incoming: ManagedContentInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for a managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentInputRepresentationNormalized {
+    /** The body of the managed content. */
+    contentBody: {
+        [key: string]: unknown;
+    };
+    /** Content space or folder id where content will be created. */
+    contentSpaceOrFolderId: string;
+    /** Fully qualified name of the content type to create. This field is required. */
+    contentType: string;
+    /** The title of the managed content. */
+    title: string;
+    /** URL-friendly identifier of the content within the org. */
+    urlName: string;
+}
+/**
+ * Input representation for a managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentInputRepresentation {
+    contentBody: {
+        [key: string]: unknown;
+    };
+    contentSpaceOrFolderId: string;
+    contentType: string;
+    title: string;
+    urlName: string;
+}

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

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

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

@@ -0,0 +1,65 @@
+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 = "8cb61e48d5546a1c3852fe6644c476de";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentJobRepresentation, existing: ManagedContentJobRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentJobRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentJobRepresentationNormalized, incoming: ManagedContentJobRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentJobRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentJobRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content import/export job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobRepresentationNormalized {
+    /** The user id who created the managed content  job */
+    createdBy: string;
+    /** The created date of the managed content  job */
+    createdDate: string;
+    /** The URL to get the error content body of a managed content  job */
+    errorBodyUrl: string;
+    /** The id of a managed content job */
+    id: string;
+    /** The URL to get the input content body of a managed content  job */
+    inputBodyUrl: string;
+    /** The type of a managed content job */
+    jobType: string;
+    /** The last user id who has modified the managed content  job */
+    lastModifiedBy: string;
+    /** The last time the managed content job has been modified */
+    lastModifiedDate: string;
+    /** The last status update date of a managed content  job */
+    lastStatusUpdateDate: string;
+    /** The name of a managed content job */
+    name: string;
+    /** The URL to get the output content body of a managed content  job */
+    outputBodyUrl: string;
+    /** The start date of a managed content  job */
+    startDate: string;
+    /** The status of a managed content  job */
+    status: string;
+}
+/**
+ * Information about a managed content import/export job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobRepresentation {
+    createdBy: string;
+    createdDate: string;
+    errorBodyUrl: string;
+    id: string;
+    inputBodyUrl: string;
+    jobType: string;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    lastStatusUpdateDate: string;
+    name: string;
+    outputBodyUrl: string;
+    startDate: string;
+    status: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentJobRequestInputRepresentation.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 = "7646f9bbf36687ea3897b12b21d6d173";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentJobRequestInputRepresentation, existing: ManagedContentJobRequestInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentJobRequestInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentJobRequestInputRepresentationNormalized, incoming: ManagedContentJobRequestInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentJobRequestInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentJobRequestInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for creating a ManagedContent import/export job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobRequestInputRepresentationNormalized {
+    /** Auto publish the data after import if that operation is permitted */
+    autoPublish: boolean;
+    /** ContentBody Id of Managed Content Import data */
+    contentBodyId: string;
+    /** Managed Content Space Id */
+    contentSpaceId: string;
+    /** Update existing content after importing data if it exists by including content key; Otherwise create new content */
+    includeContentKey: boolean;
+    /** Managed Content Job Name */
+    name: string;
+}
+/**
+ * Input representation for creating a ManagedContent import/export job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobRequestInputRepresentation {
+    autoPublish: boolean;
+    contentBodyId: string;
+    contentSpaceId: string;
+    includeContentKey: boolean;
+    name: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentLanguageSummaryRepresentation.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 = "bfb9774cd89d1fe96880107efed17f19";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentLanguageSummaryRepresentation, existing: ManagedContentLanguageSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentLanguageSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentLanguageSummaryRepresentationNormalized, incoming: ManagedContentLanguageSummaryRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentLanguageSummaryRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentLanguageSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Display Label for Language and language locale
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentLanguageSummaryRepresentationNormalized {
+    /** Display Label for Language of a managed content variant. */
+    displayLabel: string;
+    /** Language locale of a managed content variant. */
+    locale: string;
+}
+/**
+ * Display Label for Language and language locale
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentLanguageSummaryRepresentation {
+    displayLabel: string;
+    locale: string;
+}

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

@@ -0,0 +1,57 @@
+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 = "af8c456537766cfd5c8c55df42f0abb5";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentMediaNodeValueRepresentation, existing: ManagedContentMediaNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentMediaNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentMediaNodeValueRepresentationNormalized, incoming: ManagedContentMediaNodeValueRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentMediaNodeValueRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentMediaNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content node of media type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentMediaNodeValueRepresentationNormalized extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    /** The alternate text for the managed content node. */
+    altText: string;
+    /** The contentKey of managed content being referenced. */
+    contentKey: string;
+    /** The file name of the managed content node. */
+    fileName: string;
+    /** The media type of the managed content node like Image, Video or Document */
+    mediaType: string;
+    /** The mime type of the managed content node. */
+    mimeType: string;
+    /** The resource url of the managed content node. */
+    resourceUrl: string;
+    /** Media thumbnail url. */
+    thumbnailUrl: string;
+    /** The title of the managed content node. */
+    title: string;
+    /** The unauthenticated url of the managed content node. */
+    unauthenticatedUrl: string;
+    /** The url of the managed content node. */
+    url: string;
+}
+/**
+ * Information about a managed content node of media type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentMediaNodeValueRepresentation extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    altText: string;
+    contentKey: string;
+    fileName: string;
+    mediaType: string;
+    mimeType: string;
+    resourceUrl: string;
+    thumbnailUrl: string;
+    title: string;
+    unauthenticatedUrl: string;
+    url: string;
+}

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

@@ -0,0 +1,51 @@
+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 = "50e43b0c09d181a66ca9d58fbe482ccd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentMediaSourceNodeValueRepresentation, existing: ManagedContentMediaSourceNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentMediaSourceNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentMediaSourceNodeValueRepresentationNormalized, incoming: ManagedContentMediaSourceNodeValueRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentMediaSourceNodeValueRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentMediaSourceNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a source of a managed content media.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentMediaSourceNodeValueRepresentationNormalized extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    /** The file name of the media source. */
+    fileName: string;
+    /** Whether media source is uploaded or referenced via external url. */
+    isExternal: boolean;
+    /** The type of media like Image, Video or Document. */
+    mediaType: string;
+    /** The mime type of the media source. */
+    mimeType: string;
+    /** Reference id of the uploaded media source */
+    referenceId: string;
+    /** The API url to the bytes of the media source. */
+    resourceUrl: string;
+    /** The url to the bytes of the media source for unauthenticated users. */
+    unauthenticatedUrl: string;
+    /** The url to the bytes of the source for authenticated users. */
+    url: string;
+}
+/**
+ * Information about a source of a managed content media.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentMediaSourceNodeValueRepresentation extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    fileName: string;
+    isExternal: boolean;
+    mediaType: string;
+    mimeType: string;
+    referenceId: string;
+    resourceUrl: string;
+    unauthenticatedUrl: string;
+    url: string;
+}

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

@@ -0,0 +1,35 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "dfeb8fbbc5b04f5e0c137055a0501268";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentNodeTypeRepresentation, existing: ManagedContentNodeTypeRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentNodeTypeRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentNodeTypeRepresentationNormalized, incoming: ManagedContentNodeTypeRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentNodeTypeRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentNodeTypeRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content node type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentNodeTypeRepresentationNormalized {
+    /** The label of the managed content node type. */
+    label: string;
+    /** The developer name of the managed content node type. */
+    name: string;
+    /** The type of the managed content node. */
+    nodeType: string;
+}
+/**
+ * Information about a managed content node type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentNodeTypeRepresentation {
+    label: string;
+    name: string;
+    nodeType: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentNodeValueRepresentation.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 = "f459a0803edcf8950c25232fba362a00";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentNodeValueRepresentation, existing: ManagedContentNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentNodeValueRepresentationNormalized, incoming: ManagedContentNodeValueRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentNodeValueRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content node.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentNodeValueRepresentationNormalized {
+    /** The type of the managed content node. */
+    nodeType: string;
+}
+/**
+ * Information about a managed content node.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentNodeValueRepresentation {
+    nodeType: string;
+}

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

@@ -0,0 +1,30 @@
+import { ManagedContentPreviewRepresentation as ManagedContentPreviewRepresentation_ManagedContentPreviewRepresentation } from './ManagedContentPreviewRepresentation';
+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 = "2ea0d489f57171bd8c65e01f79843327";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentPreviewCollectionRepresentation, existing: ManagedContentPreviewCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentPreviewCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentPreviewCollectionRepresentationNormalized, incoming: ManagedContentPreviewCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentPreviewCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentPreviewCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection of Managed Content Previews
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentPreviewCollectionRepresentationNormalized {
+    /** ManagedContentPreview collection */
+    previews: Array<ManagedContentPreviewRepresentation_ManagedContentPreviewRepresentation>;
+}
+/**
+ * Collection of Managed Content Previews
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentPreviewCollectionRepresentation {
+    previews: Array<ManagedContentPreviewRepresentation_ManagedContentPreviewRepresentation>;
+}