@salesforce/lds-adapters-experience-model 0.1.0-dev1

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

@@ -0,0 +1,31 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "686f011ca27b8ed002b256ce82b32841";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderInputRep, existing: ManagedContentSpaceFolderInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderInputRepNormalized, incoming: ManagedContentSpaceFolderInputRepNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation of a content space folder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderInputRepNormalized {
+    /** The name of the folder */
+    name: string;
+    /** Parent folder id */
+    parentFolderId: string;
+}
+/**
+ * Input representation of a content space folder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderInputRep {
+    name: string;
+    parentFolderId: string;
+}

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

@@ -0,0 +1,31 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "d9cfda700d3293277cc91f1818cbbb3f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderItemCollectionInputRep, existing: ManagedContentSpaceFolderItemCollectionInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderItemCollectionInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderItemCollectionInputRepNormalized, incoming: ManagedContentSpaceFolderItemCollectionInputRepNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderItemCollectionInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection input of ManagedContentSpaceFolderItems for Move operation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemCollectionInputRepNormalized {
+    /** ID of the new parent folder to the items should be moved */
+    folderId: string;
+    /** List of IDs of the folder items that need to be moved */
+    folderItems: Array<string>;
+}
+/**
+ * Collection input of ManagedContentSpaceFolderItems for Move operation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemCollectionInputRep {
+    folderId: string;
+    folderItems: Array<string>;
+}

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

@@ -0,0 +1,35 @@
+import { ManagedContentSpaceFolderItemRepresentation as ManagedContentSpaceFolderItemRepresentation_ManagedContentSpaceFolderItemRepresentation } from './ManagedContentSpaceFolderItemRepresentation';
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "7142324f6c1f6094fb64005991a76983";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderItemCollectionRepresentation, existing: ManagedContentSpaceFolderItemCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderItemCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderItemCollectionRepresentationNormalized, incoming: ManagedContentSpaceFolderItemCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderItemCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection Representation of folder items inside in ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemCollectionRepresentationNormalized {
+    /** The id of the folder */
+    folderId: string;
+    /** The list of the folder items - ManagedContent or ManagedContentSpaceFolder */
+    folderItems: Array<ManagedContentSpaceFolderItemRepresentation_ManagedContentSpaceFolderItemRepresentation>;
+    /** The id of the parent folder */
+    parentFolderId: string;
+}
+/**
+ * Collection Representation of folder items inside in ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemCollectionRepresentation {
+    folderId: string;
+    folderItems: Array<ManagedContentSpaceFolderItemRepresentation_ManagedContentSpaceFolderItemRepresentation>;
+    parentFolderId: string;
+}

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

@@ -0,0 +1,64 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "553349b68e5f0fe8c8c94865e21acfeb";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderItemRepresentation, existing: ManagedContentSpaceFolderItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderItemRepresentationNormalized, incoming: ManagedContentSpaceFolderItemRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of a folder item inside a ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemRepresentationNormalized {
+    /** The ContentKey of the ManagedContent */
+    contentKey: string;
+    /** The User ID for the user which created the ManagedContent or ManagedContentSpaceFolder */
+    createdBy: string;
+    /** The date when the ManagedContent or ManagedContentSpaceFolder was created */
+    createdDate: string;
+    /** Boolean flag to indicate whether this folder has child folders */
+    hasChildFolders: boolean;
+    /** The id of the folder item - ManagedContent or ManagedContentSpaceFolder */
+    id: string;
+    /** Boolean flag to indicate whether this folder item is a folder */
+    isFolder: boolean;
+    /** The User ID for the user which last modified the ManagedContent or ManagedContentSpaceFolder */
+    lastModifiedBy: string;
+    /** The date when the ManagedContent or ManagedContentSpaceFolder was last modified */
+    lastModifiedDate: string;
+    /** Developer Name for the ManagedContentType if the folder item is ManagedContent */
+    managedContentType: string;
+    /** Latest Managed Content Version Id of the folder item is ManagedContent */
+    managedContentVersionId: string;
+    /** Date when the ManagedContent was last published */
+    publishedDate: string;
+    /** Status of the Managed Content */
+    status: string;
+    /** Title of the ManagedContent/ManagedContentSpaceFolder */
+    title: string;
+}
+/**
+ * Representation of a folder item inside a ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemRepresentation {
+    contentKey: string;
+    createdBy: string;
+    createdDate: string;
+    hasChildFolders: boolean;
+    id: string;
+    isFolder: boolean;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    managedContentType: string;
+    managedContentVersionId: string;
+    publishedDate: string;
+    status: string;
+    title: string;
+}

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

@@ -0,0 +1,26 @@
+import { AbstractMCSFolderRepresentation as AbstractMCSFolderRepresentation_AbstractMCSFolderRepresentation } from './AbstractMCSFolderRepresentation';
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "419fce7b0af83dae123313032e8aba4e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderRepresentation, existing: ManagedContentSpaceFolderRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderRepresentationNormalized, incoming: ManagedContentSpaceFolderRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Base Representation of a CMS Folder i.e. ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderRepresentationNormalized extends AbstractMCSFolderRepresentation_AbstractMCSFolderRepresentation {
+}
+/**
+ * Base Representation of a CMS Folder i.e. ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderRepresentation extends AbstractMCSFolderRepresentation_AbstractMCSFolderRepresentation {
+}

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

@@ -0,0 +1,29 @@
+import { ManagedContentSpaceMemberRepresentation as ManagedContentSpaceMemberRepresentation_ManagedContentSpaceMemberRepresentation } from './ManagedContentSpaceMemberRepresentation';
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "d19182489a6cddb99b78a92559ce50c9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceMemberCollectionRepresentation, existing: ManagedContentSpaceMemberCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceMemberCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceMemberCollectionRepresentationNormalized, incoming: ManagedContentSpaceMemberCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceMemberCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection representation of the members in a content space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberCollectionRepresentationNormalized {
+    /** List of the members in the content space */
+    members: Array<ManagedContentSpaceMemberRepresentation_ManagedContentSpaceMemberRepresentation>;
+}
+/**
+ * Collection representation of the members in a content space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberCollectionRepresentation {
+    members: Array<ManagedContentSpaceMemberRepresentation_ManagedContentSpaceMemberRepresentation>;
+}

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

@@ -0,0 +1,31 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "aa02c2b3dc29696236da41cfa5c2fccb";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceMemberInputRepresentation, existing: ManagedContentSpaceMemberInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceMemberInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceMemberInputRepresentationNormalized, incoming: ManagedContentSpaceMemberInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceMemberInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation of a content space member
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberInputRepresentationNormalized {
+    /** The ID of the user/group to assign the role in the content space */
+    memberId: string;
+    /** The ID of the role to assign the user as, in the content space */
+    roleId: string;
+}
+/**
+ * Input representation of a content space member
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberInputRepresentation {
+    memberId: string;
+    roleId: string;
+}

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

@@ -0,0 +1,37 @@
+import { ManagedContentSpacePermissionRepresentation as ManagedContentSpacePermissionRepresentation_ManagedContentSpacePermissionRepresentation } from './ManagedContentSpacePermissionRepresentation';
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "084fc7931f796f3ea348be92f513babe";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceMemberPermissionsRepresentation, existing: ManagedContentSpaceMemberPermissionsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceMemberPermissionsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceMemberPermissionsRepresentationNormalized, incoming: ManagedContentSpaceMemberPermissionsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceMemberPermissionsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of permissions of a member in a content space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberPermissionsRepresentationNormalized {
+    /** A map of permissions for a member grouped by different scopes and consequently spaceContentTypes */
+    permissions: {
+        [key: string]: {
+            [key: string]: ManagedContentSpacePermissionRepresentation_ManagedContentSpacePermissionRepresentation;
+        };
+    };
+}
+/**
+ * Representation of permissions of a member in a content space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberPermissionsRepresentation {
+    permissions: {
+        [key: string]: {
+            [key: string]: ManagedContentSpacePermissionRepresentation_ManagedContentSpacePermissionRepresentation;
+        };
+    };
+}

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

@@ -0,0 +1,34 @@
+import { ManagedContentSpaceRoleRepresentation as ManagedContentSpaceRoleRepresentation_ManagedContentSpaceRoleRepresentation } from './ManagedContentSpaceRoleRepresentation';
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "ce923c41b95874dccf972705c4f25f77";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceMemberRepresentation, existing: ManagedContentSpaceMemberRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceMemberRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceMemberRepresentationNormalized, incoming: ManagedContentSpaceMemberRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceMemberRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of a ManagedContentSpaceMember
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberRepresentationNormalized {
+    /** The id of managedContentSpaceMember entity object */
+    id: string;
+    /** The user / group id */
+    memberId: string;
+    role: ManagedContentSpaceRoleRepresentation_ManagedContentSpaceRoleRepresentation;
+}
+/**
+ * Representation of a ManagedContentSpaceMember
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberRepresentation {
+    id: string;
+    memberId: string;
+    role: ManagedContentSpaceRoleRepresentation_ManagedContentSpaceRoleRepresentation;
+}

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

@@ -0,0 +1,49 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "de5a3f0aba66c1aedb6a8cf21e0e6cd2";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpacePermissionRepresentation, existing: ManagedContentSpacePermissionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpacePermissionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpacePermissionRepresentationNormalized, incoming: ManagedContentSpacePermissionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpacePermissionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of a permission bit vector based on a scopeType or contentTypeIdOrEnum
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpacePermissionRepresentationNormalized {
+    /** Does the member have create access for the scopeType and spaceContentType */
+    canCreate: boolean;
+    /** Does the member have delete access for the scopeType and spaceContentType */
+    canDelete: boolean;
+    /** Does the member have manage access for the scopeType and spaceContentType */
+    canManage: boolean;
+    /** Does the member have publish/unpublish access for the scopeType and spaceContentType */
+    canPublish: boolean;
+    /** Does the member have read access for the scopeType and spaceContentType */
+    canRead: boolean;
+    /** Does the member have schedule access for the scopeType and spaceContentType */
+    canSchedule: boolean;
+    /** Does the member have translate access for the scopeType and spaceContentType */
+    canTranslate: boolean;
+    /** Does the member have update access for the scopeType and spaceContentType */
+    canUpdate: boolean;
+}
+/**
+ * Representation of a permission bit vector based on a scopeType or contentTypeIdOrEnum
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpacePermissionRepresentation {
+    canCreate: boolean;
+    canDelete: boolean;
+    canManage: boolean;
+    canPublish: boolean;
+    canRead: boolean;
+    canSchedule: boolean;
+    canTranslate: boolean;
+    canUpdate: boolean;
+}

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

@@ -0,0 +1,55 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "9742049591a0f7a9f6718f4a18b565b7";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceRepresentation, existing: ManagedContentSpaceRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceRepresentationNormalized, incoming: ManagedContentSpaceRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Details of a Managed Content Space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceRepresentationNormalized {
+    /** User-Id of the creator of the Managed Content Space */
+    createdBy: string;
+    /** Date of creation of the Managed Content Space */
+    createdDate: string;
+    /** Default Language of the Managed Content Space */
+    defaultLanguage: string;
+    /** Description of the Managed Content Space */
+    description: string;
+    /** Id of the Managed Content Space */
+    id: string;
+    /** User-Id of the user who last modified the Managed Content Space */
+    lastModifiedBy: string;
+    /** Date on which the Managed Content Space was last modified */
+    lastModifiedDate: string;
+    /** Name of the Managed Content Space */
+    name: string;
+    /** Root Folder Id of the Managed Content Space */
+    rootFolderId: string;
+    /** Set of supported languages in the Managed Content Space */
+    supportedLanguages: Array<string>;
+}
+/**
+ * Details of a Managed Content Space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceRepresentation {
+    createdBy: string;
+    createdDate: string;
+    defaultLanguage: string;
+    description: string;
+    id: string;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    name: string;
+    rootFolderId: string;
+    supportedLanguages: Array<string>;
+}

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

@@ -0,0 +1,29 @@
+import { ManagedContentSpaceRoleRepresentation as ManagedContentSpaceRoleRepresentation_ManagedContentSpaceRoleRepresentation } from './ManagedContentSpaceRoleRepresentation';
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "332f49232e25346824252c100fc484bd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceRoleCollectionRepresentation, existing: ManagedContentSpaceRoleCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceRoleCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceRoleCollectionRepresentationNormalized, incoming: ManagedContentSpaceRoleCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceRoleCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection representation of the roles in a content space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceRoleCollectionRepresentationNormalized {
+    /** List of the roles in the content space */
+    roles: Array<ManagedContentSpaceRoleRepresentation_ManagedContentSpaceRoleRepresentation>;
+}
+/**
+ * Collection representation of the roles in a content space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceRoleCollectionRepresentation {
+    roles: Array<ManagedContentSpaceRoleRepresentation_ManagedContentSpaceRoleRepresentation>;
+}

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

@@ -0,0 +1,34 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "b5f70db0d211782d4a07f0c4b75fea95";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceRoleRepresentation, existing: ManagedContentSpaceRoleRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceRoleRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceRoleRepresentationNormalized, incoming: ManagedContentSpaceRoleRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceRoleRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of a ManagedContentSpaceRole
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceRoleRepresentationNormalized {
+    /** The role description */
+    description: string;
+    /** The role ID */
+    id: string;
+    /** The role name */
+    name: string;
+}
+/**
+ * Representation of a ManagedContentSpaceRole
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceRoleRepresentation {
+    description: string;
+    id: string;
+    name: string;
+}

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

@@ -0,0 +1,31 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "577d4cf32ca399b09e4ba4e247533276";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceSummaryRepresentation, existing: ManagedContentSpaceSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceSummaryRepresentationNormalized, incoming: ManagedContentSpaceSummaryRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content space.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceSummaryRepresentationNormalized {
+    /** Id of the managed content space. */
+    id: string;
+    /** Connect API resource url to ge more information about managed content space. */
+    resourceUrl: string;
+}
+/**
+ * Information about a managed content space.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceSummaryRepresentation {
+    id: string;
+    resourceUrl: string;
+}

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

@@ -0,0 +1,29 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "73b81646c0ca6dcfd69e957aedca7ea7";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTextNodeValueRepresentation, existing: ManagedContentTextNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTextNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTextNodeValueRepresentationNormalized, incoming: ManagedContentTextNodeValueRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTextNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content node of type text.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTextNodeValueRepresentationNormalized extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    /** The text value of the managed content node. */
+    value: string;
+}
+/**
+ * Information about a managed content node of type text.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTextNodeValueRepresentation extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    value: string;
+}

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

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