@salesforce/lds-adapters-cms-authoring 0.131.0

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

@@ -0,0 +1,39 @@
+import { ManagedContentTypeSearchableRepresentation as ManagedContentTypeSearchableRepresentation_ManagedContentTypeSearchableRepresentation } from './ManagedContentTypeSearchableRepresentation';
+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 = "a8a32a6ec22fd17bf143c7771d77fcda";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTypeSearchableCollectionRepresentation, existing: ManagedContentTypeSearchableCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTypeSearchableCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTypeSearchableCollectionRepresentationNormalized, incoming: ManagedContentTypeSearchableCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentTypeSearchableCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentTypeSearchableCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection of Content Type Search Status
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSearchableCollectionRepresentationNormalized {
+    /** URL to the current page of Manage Content Type Search Status records. The default is 25 managed content channels per page. */
+    currentPageUrl: string;
+    /** Manage Content Type Searchable records corresponding to the current page */
+    items: Array<ManagedContentTypeSearchableRepresentation_ManagedContentTypeSearchableRepresentation>;
+    /** URL to the next page of Manage Content Type Search Status records. The default is 25 managed content channels per page. */
+    nextPageUrl: string;
+    /** Total count of Manage Content Type Search Status records across all pages */
+    totalItems: number;
+}
+/**
+ * Collection of Content Type Search Status
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSearchableCollectionRepresentation {
+    currentPageUrl: string;
+    items: Array<ManagedContentTypeSearchableRepresentation_ManagedContentTypeSearchableRepresentation>;
+    nextPageUrl: string;
+    totalItems: number;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentTypeSearchableInputRepresentation.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 = "252d902ecbe79b3576c4ca5293006f4e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTypeSearchableInputRepresentation, existing: ManagedContentTypeSearchableInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTypeSearchableInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTypeSearchableInputRepresentationNormalized, incoming: ManagedContentTypeSearchableInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentTypeSearchableInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentTypeSearchableInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * The input representation for a content type search status
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSearchableInputRepresentationNormalized {
+    /** Searchable status of the Content Type */
+    isSearchable: boolean;
+    /** Name of the Content Type */
+    name: string;
+}
+/**
+ * The input representation for a content type search status
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSearchableInputRepresentation {
+    isSearchable: boolean;
+    name: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentTypeSearchableRepresentation.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 = "39f5f40a7cb00564def69cc8aa583c84";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTypeSearchableRepresentation, existing: ManagedContentTypeSearchableRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTypeSearchableRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTypeSearchableRepresentationNormalized, incoming: ManagedContentTypeSearchableRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentTypeSearchableRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentTypeSearchableRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Details of a Managed Content Type Search Status
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSearchableRepresentationNormalized {
+    /** Id of the Managed Content Type */
+    id: string;
+    /** Is the contentType searchable */
+    isSearchable: boolean;
+    /** Master label of the Managed Content Type */
+    label: string;
+    /** Developer Name of the Managed Content Type */
+    name: string;
+}
+/**
+ * Details of a Managed Content Type Search Status
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSearchableRepresentation {
+    id: string;
+    isSearchable: boolean;
+    label: string;
+    name: string;
+}

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

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

@@ -0,0 +1,39 @@
+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 = "0fcbd23a3c3f7b6222d948b3169bc0df";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTypeViewRepresentation, existing: ManagedContentTypeViewRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTypeViewRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTypeViewRepresentationNormalized, incoming: ManagedContentTypeViewRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentTypeViewRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentTypeViewRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Representation of managed content type view list
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeViewRepresentationNormalized {
+    /** View associated with the schema */
+    view: {
+        [key: string]: {};
+    };
+    /** View Mode of current view. */
+    viewMode: string;
+    /** View type of current view. */
+    viewType: string;
+}
+/**
+ * Representation of managed content type view list
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeViewRepresentation {
+    view: {
+        [key: string]: {};
+    };
+    viewMode: string;
+    viewType: string;
+}

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

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

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

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

@@ -0,0 +1,45 @@
+import { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 100;
+export declare const VERSION = "2f473ff12e87a4fc2336695104ab8567";
+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 ManagedContentUnpublishOutputRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentUnpublishOutputRepresentationNormalizedKeyMetadata = 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): ManagedContentUnpublishOutputRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentUnpublishOutputRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentUnpublishOutputRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentUnpublishOutputRepresentation, existing: ManagedContentUnpublishOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentUnpublishOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentUnpublishOutputRepresentationNormalized, incoming: ManagedContentUnpublishOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentUnpublishOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentUnpublishOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a Unpublished action
+ *
+ * Keys:
+ *    id (string): deploymentId
+ */
+export interface ManagedContentUnpublishOutputRepresentationNormalized {
+    /** ManagedContentDeployment Entity Id */
+    deploymentId: string;
+    /** Provided description. */
+    description: string | null;
+    /** Unpublish Date */
+    unpublishDate: string | null;
+}
+/**
+ * Information about a Unpublished action
+ *
+ * Keys:
+ *    id (string): deploymentId
+ */
+export interface ManagedContentUnpublishOutputRepresentation {
+    deploymentId: string;
+    description: string | null;
+    unpublishDate: string | null;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentUserSummaryRepresentation.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 = "4b75ed6ff448da86412b605f7e775a62";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentUserSummaryRepresentation, existing: ManagedContentUserSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentUserSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentUserSummaryRepresentationNormalized, incoming: ManagedContentUserSummaryRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentUserSummaryRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentUserSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a user who created/modified content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentUserSummaryRepresentationNormalized {
+    /** The id of the user. */
+    id: string;
+    /** The name of the user. */
+    name?: string;
+    /** The connect endpoint resourceUrl of the user to get more information about the user. */
+    resourceUrl: string;
+}
+/**
+ * Information about a user who created/modified content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentUserSummaryRepresentation {
+    id: string;
+    name?: string;
+    resourceUrl: string;
+}

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

@@ -0,0 +1,75 @@
+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 = "9ae4bb8336d074517f1c980f5f3f7d82";
+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 ManagedContentV2JobRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentV2JobRepresentationNormalizedKeyMetadata = 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): ManagedContentV2JobRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentV2JobRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentV2JobRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentV2JobRepresentation, existing: ManagedContentV2JobRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentV2JobRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentV2JobRepresentationNormalized, incoming: ManagedContentV2JobRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentV2JobRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentV2JobRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content import/export job
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface ManagedContentV2JobRepresentationNormalized {
+    /** 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 | null;
+    /** The id of a managed content job */
+    id: string;
+    /** The URL to get the input content body of a managed content  job */
+    inputBodyUrl: string | null;
+    /** 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 | null;
+    /** The start date of a managed content  job */
+    startDate: string | null;
+    /** The status of a managed content  job */
+    status: string;
+}
+/**
+ * Information about a managed content import/export job
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface ManagedContentV2JobRepresentation {
+    createdBy: string;
+    createdDate: string;
+    errorBodyUrl: string | null;
+    id: string;
+    inputBodyUrl: string | null;
+    jobType: string;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    lastStatusUpdateDate: string;
+    name: string;
+    outputBodyUrl: string | null;
+    startDate: string | null;
+    status: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentV2JobRequestInputRepresentation.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 = "1bf57fa15968df9f6b0790571cd4e25d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentV2JobRequestInputRepresentation, existing: ManagedContentV2JobRequestInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentV2JobRequestInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentV2JobRequestInputRepresentationNormalized, incoming: ManagedContentV2JobRequestInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentV2JobRequestInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentV2JobRequestInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for creating a ManagedContent import job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentV2JobRequestInputRepresentationNormalized {
+    /** Auto publish the data after import if that operation is permitted */
+    autoPublish: boolean;
+    /** ManagedContentBody Id of Managed Content Import data */
+    managedContentBodyId: string;
+    /** Managed Content Job Name */
+    name: string;
+}
+/**
+ * Input representation for creating a ManagedContent import job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentV2JobRequestInputRepresentation {
+    autoPublish: boolean;
+    managedContentBodyId: string;
+    name: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentVariantInputRepresentation.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 = "23a396fca78d094080b600b5537ef514";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVariantInputRepresentation, existing: ManagedContentVariantInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVariantInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentVariantInputRepresentationNormalized, incoming: ManagedContentVariantInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentVariantInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentVariantInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for a managed variant.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVariantInputRepresentationNormalized {
+    /** The body of the managed content. */
+    contentBody: {
+        [key: string]: unknown;
+    };
+    /** The language of the variant */
+    language: string;
+    /** The managed content key or ID which is the content associated to the variant to be created */
+    managedContentKeyOrId: string;
+    /** The title of the managed content variant */
+    title?: string;
+    /** URL-friendly identifier of the content within the org. */
+    urlName?: string;
+}
+/**
+ * Input representation for a managed variant.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVariantInputRepresentation {
+    contentBody: {
+        [key: string]: unknown;
+    };
+    language: string;
+    managedContentKeyOrId: string;
+    title?: string;
+    urlName?: string;
+}

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

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

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

@@ -0,0 +1,67 @@
+import { ManagedContentTypeSummaryRepresentation as ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation } from './ManagedContentTypeSummaryRepresentation';
+import { ManagedContentUserSummaryRepresentation as ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation } from './ManagedContentUserSummaryRepresentation';
+import { ManagedContentLanguageSummaryRepresentation as ManagedContentLanguageSummaryRepresentation_ManagedContentLanguageSummaryRepresentation } from './ManagedContentLanguageSummaryRepresentation';
+import { ManagedContentVariantStatusRepresentation as ManagedContentVariantStatusRepresentation_ManagedContentVariantStatusRepresentation } from './ManagedContentVariantStatusRepresentation';
+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 = "9c048b627f36dc08a9fef8f96dfd1c5a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVariantReferenceDetailsRepresentation, existing: ManagedContentVariantReferenceDetailsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVariantReferenceDetailsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentVariantReferenceDetailsRepresentationNormalized, incoming: ManagedContentVariantReferenceDetailsRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentVariantReferenceDetailsRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentVariantReferenceDetailsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about referenced content variants
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVariantReferenceDetailsRepresentationNormalized {
+    /** ContentKey of this reference Variant’s content */
+    contentKey: string;
+    /** Variant content type */
+    contentType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    /** User created this variant */
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** Date variant got created */
+    createdDate: string;
+    /** Indicates whether this Variant is ready for publish */
+    isReady: boolean;
+    /** Variant language */
+    language: ManagedContentLanguageSummaryRepresentation_ManagedContentLanguageSummaryRepresentation;
+    /** User  last modified this variant */
+    lastModifiedBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** Date variant got last modified */
+    lastModifiedDate: string;
+    /** managedContentId of this reference Variant’s content */
+    managedContentId: string;
+    /** Reference Variant id */
+    managedContentVariantId: string;
+    /** Indicates variant status.
+     */
+    status: ManagedContentVariantStatusRepresentation_ManagedContentVariantStatusRepresentation;
+    /** Title of the variant */
+    title: string;
+}
+/**
+ * Information about referenced content variants
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVariantReferenceDetailsRepresentation {
+    contentKey: string;
+    contentType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    createdDate: string;
+    isReady: boolean;
+    language: ManagedContentLanguageSummaryRepresentation_ManagedContentLanguageSummaryRepresentation;
+    lastModifiedBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    lastModifiedDate: string;
+    managedContentId: string;
+    managedContentVariantId: string;
+    status: ManagedContentVariantStatusRepresentation_ManagedContentVariantStatusRepresentation;
+    title: string;
+}

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

@@ -0,0 +1,35 @@
+import { ManagedContentVariantReferenceDetailsRepresentation as ManagedContentVariantReferenceDetailsRepresentation_ManagedContentVariantReferenceDetailsRepresentation } from './ManagedContentVariantReferenceDetailsRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 100;
+export declare const VERSION = "944ebf1d8e72c74b2d0a208b3dfa8326";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVariantReferencesCollectionRepresentation, existing: ManagedContentVariantReferencesCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVariantReferencesCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentVariantReferencesCollectionRepresentationNormalized, incoming: ManagedContentVariantReferencesCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentVariantReferencesCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentVariantReferencesCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection of Reference variants
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVariantReferencesCollectionRepresentationNormalized {
+    /** Reference variants collection */
+    referenceVariants: {
+        [key: string]: Array<ManagedContentVariantReferenceDetailsRepresentation_ManagedContentVariantReferenceDetailsRepresentation>;
+    };
+}
+/**
+ * Collection of Reference variants
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVariantReferencesCollectionRepresentation {
+    referenceVariants: {
+        [key: string]: Array<ManagedContentVariantReferenceDetailsRepresentation_ManagedContentVariantReferenceDetailsRepresentation>;
+    };
+}