@salesforce/lds-adapters-cms-authoring 0.1.0-dev1

package/dist/es/es2018/types/src/generated/types/ManagedContentFailedVariantsRepresentation.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 = "4fad4faa0bf5fd47ecb6dc7c0a40f8b0";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentFailedVariantsRepresentation, existing: ManagedContentFailedVariantsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentFailedVariantsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentFailedVariantsRepresentationNormalized, incoming: ManagedContentFailedVariantsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentFailedVariantsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information of failed variants when content cloning was partial success.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentFailedVariantsRepresentationNormalized {
+    /** Error message mentioning the reason of failure. */
+    errorMessage: string;
+    /** Language of failed translated variant. */
+    language: string;
+    /** Managed Content Variant ID of variant which failed to clone. */
+    sourceManagedContentVariantId: string;
+}
+/**
+ * Information of failed variants when content cloning was partial success.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentFailedVariantsRepresentation {
+    errorMessage: string;
+    language: string;
+    sourceManagedContentVariantId: string;
+}

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

@@ -0,0 +1,29 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } 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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentFolderSearchResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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,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 = "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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentFolderSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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/ManagedContentFormEmbedScriptInputRepresentation.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 = "d2c6e62289bb2626e563f1b7bcfa7f64";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentFormEmbedScriptInputRepresentation, existing: ManagedContentFormEmbedScriptInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentFormEmbedScriptInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentFormEmbedScriptInputRepresentationNormalized, incoming: ManagedContentFormEmbedScriptInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentFormEmbedScriptInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input to generate an embed script for external form.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentFormEmbedScriptInputRepresentationNormalized {
+    /** Domain name of the external site where form is hosted. */
+    domainName: string;
+    /** CMS content key for the form that's to be used on an external site. */
+    formContentKey: string;
+}
+/**
+ * Input to generate an embed script for external form.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentFormEmbedScriptInputRepresentation {
+    domainName: string;
+    formContentKey: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentFormEmbedScriptRepresentation.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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const TTL = 1000;
+export declare const VERSION = "cc509706cdcf28fd1e133dd3df7ed8a0";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentFormEmbedScriptRepresentation, existing: ManagedContentFormEmbedScriptRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentFormEmbedScriptRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentFormEmbedScriptRepresentationNormalized, incoming: ManagedContentFormEmbedScriptRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentFormEmbedScriptRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents the embed script for external form.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentFormEmbedScriptRepresentationNormalized {
+    /** The code snippet for the external form. */
+    extFormCodeSnippet: string;
+}
+/**
+ * Represents the embed script for external form.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentFormEmbedScriptRepresentation {
+    extFormCodeSnippet: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentFormHandlerEmbedScriptRepresentation.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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const TTL = 1000;
+export declare const VERSION = "6a20423e3432da857b15655ba215a3b6";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentFormHandlerEmbedScriptRepresentation, existing: ManagedContentFormHandlerEmbedScriptRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentFormHandlerEmbedScriptRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentFormHandlerEmbedScriptRepresentationNormalized, incoming: ManagedContentFormHandlerEmbedScriptRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentFormHandlerEmbedScriptRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents the embed script for form handler.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentFormHandlerEmbedScriptRepresentationNormalized {
+    /** The form script for the embed script for form Handler. */
+    formScript: string;
+    /** The host script for the embed script for form Handler. */
+    hostScript: string;
+}
+/**
+ * Represents the embed script for form handler.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentFormHandlerEmbedScriptRepresentation {
+    formScript: string;
+    hostScript: string;
+}

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

@@ -0,0 +1,28 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } 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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentImportV2JobRequestInputWrapperRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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,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 = "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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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,50 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "86971f98fbfe2baeacebd4372f211dd2";
+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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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;
+    /** External ID. Optional. */
+    externalId?: string;
+    /** External source in which content is created. Optional. */
+    externalSource?: {};
+    /** 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;
+    externalId?: string;
+    externalSource?: {};
+    title?: string;
+    urlName?: string;
+}

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

@@ -0,0 +1,28 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } 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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentInputWrapperRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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/ManagedContentJobBodyCollectionRepresentation.d.ts

@@ -0,0 +1,29 @@
+import { ManagedContentJobBodyRepresentation as ManagedContentJobBodyRepresentation_ManagedContentJobBodyRepresentation } from './ManagedContentJobBodyRepresentation';
+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 = "eba1876bba76cb05d9cbb8a968bd6796";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentJobBodyCollectionRepresentation, existing: ManagedContentJobBodyCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentJobBodyCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentJobBodyCollectionRepresentationNormalized, incoming: ManagedContentJobBodyCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentJobBodyCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about managed content job body
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobBodyCollectionRepresentationNormalized {
+    /** A list of bodies e.g. input, output or error for a managed content job */
+    jobBodies: Array<ManagedContentJobBodyRepresentation_ManagedContentJobBodyRepresentation>;
+}
+/**
+ * Information about managed content job body
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobBodyCollectionRepresentation {
+    jobBodies: Array<ManagedContentJobBodyRepresentation_ManagedContentJobBodyRepresentation>;
+}

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

@@ -0,0 +1,37 @@
+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 = "7e57fd77c4503be9a8822f2603a04df3";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentJobBodyRepresentation, existing: ManagedContentJobBodyRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentJobBodyRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentJobBodyRepresentationNormalized, incoming: ManagedContentJobBodyRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentJobBodyRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content job body
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobBodyRepresentationNormalized {
+    /** The bodyType of a managed content job body */
+    bodyType: string;
+    /** The id of a managed content job */
+    id: string;
+    /** The name of a managed content job */
+    name: string;
+    /** The url of a managed content job body */
+    url: string;
+}
+/**
+ * Information about a managed content job body
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobBodyRepresentation {
+    bodyType: string;
+    id: string;
+    name: string;
+    url: string;
+}

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

@@ -0,0 +1,48 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, ResourceIngest as $64$luvio_engine_ResourceIngest, FragmentSelection as $64$luvio_engine_FragmentSelection, LinkSelection as $64$luvio_engine_LinkSelection, StoreLink as $64$luvio_engine_StoreLink, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+import { ManagedContentV2JobDetailRepresentation as ManagedContentV2JobDetailRepresentation_ManagedContentV2JobDetailRepresentation } from './ManagedContentV2JobDetailRepresentation';
+export declare const TTL = 100;
+export declare const VERSION = "75cfd71e168144693d36fa16f7d8f4d0";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentJobCollectionRepresentation, existing: ManagedContentJobCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentJobCollectionRepresentationNormalized;
+export interface DynamicIngestParams {
+    jobs: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: ManagedContentJobCollectionRepresentation, existing: ManagedContentJobCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => ManagedContentJobCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    jobs?: $64$luvio_engine_LinkSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentJobCollectionRepresentationNormalized, incoming: ManagedContentJobCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentJobCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * Collection of ManagedContent Jobs
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobCollectionRepresentationNormalized {
+    /** URL to the current page of Managed Content Jobs records. */
+    currentPageUrl: string;
+    /** ManagedContentJob Collection */
+    jobs: Array<$64$luvio_engine_StoreLink>;
+    /** URL to the next page of Managed Content jobs records. */
+    nextPageUrl: string | null;
+    /** URL to the previous page of Managed Content jobs records. */
+    previousPageUrl: string | null;
+}
+/**
+ * Collection of ManagedContent Jobs
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobCollectionRepresentation {
+    currentPageUrl: string;
+    jobs: Array<ManagedContentV2JobDetailRepresentation_ManagedContentV2JobDetailRepresentation>;
+    nextPageUrl: string | null;
+    previousPageUrl: string | null;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentJobRepresentation.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 = "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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentJobRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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,40 @@
+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 = "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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentJobRequestInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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,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 = "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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentLanguageSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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/ManagedContentLlmTranslationInputRepresentation.d.ts

@@ -0,0 +1,28 @@
+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 = "ea418ba03ec7783dcf87e8e3fb98988a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentLlmTranslationInputRepresentation, existing: ManagedContentLlmTranslationInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentLlmTranslationInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentLlmTranslationInputRepresentationNormalized, incoming: ManagedContentLlmTranslationInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentLlmTranslationInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation of a translation request using LLM
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentLlmTranslationInputRepresentationNormalized {
+    /** Indicates the target languages for the export action */
+    targetLanguages: Array<string>;
+}
+/**
+ * Input representation of a translation request using LLM
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentLlmTranslationInputRepresentation {
+    targetLanguages: Array<string>;
+}