@salesforce/lds-adapters-industries-assessment 1.100.2

package/dist/types/src/generated/adapters/adapter-utils.d.ts

@@ -0,0 +1,66 @@
+import { Adapter as $64$luvio_engine_Adapter, Snapshot as $64$luvio_engine_Snapshot, UnfulfilledSnapshot as $64$luvio_engine_UnfulfilledSnapshot } from '@luvio/engine';
+export declare const ObjectPrototypeHasOwnProperty: (v: PropertyKey) => boolean;
+declare const ObjectKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, ObjectFreeze: {
+    <T extends Function>(f: T): T;
+    <T_1 extends {
+        [idx: string]: object | U | null | undefined;
+    }, U extends string | number | bigint | boolean | symbol>(o: T_1): Readonly<T_1>;
+    <T_2>(o: T_2): Readonly<T_2>;
+}, ObjectCreate: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+};
+export { ObjectFreeze, ObjectCreate, ObjectKeys };
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const ArrayPrototypePush: (...items: any[]) => number;
+export interface AdapterValidationConfig {
+    displayName: string;
+    parameters: {
+        required: string[];
+        optional: string[];
+        unsupported?: string[];
+    };
+}
+/**
+ * Validates an adapter config is well-formed.
+ * @param config The config to validate.
+ * @param adapter The adapter validation configuration.
+ * @param oneOf The keys the config must contain at least one of.
+ * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+ */
+export declare function validateConfig<T>(config: Untrusted<T>, adapter: AdapterValidationConfig, oneOf?: string[]): void;
+export declare function untrustedIsObject<Base>(untrusted: unknown): untrusted is Untrusted<Base>;
+export type UncoercedConfiguration<Base, Options extends {
+    [key in keyof Base]?: any;
+}> = {
+    [Key in keyof Base]?: Base[Key] | Options[Key];
+};
+export type Untrusted<Base> = Partial<Base>;
+export declare function areRequiredParametersPresent<T>(config: any, configPropertyNames: AdapterValidationConfig): config is T;
+export declare function refreshable<C, D, R>(adapter: $64$luvio_engine_Adapter<C, D>, resolve: (config: unknown) => Promise<$64$luvio_engine_Snapshot<R>>): $64$luvio_engine_Adapter<C, D>;
+export declare const SNAPSHOT_STATE_FULFILLED = "Fulfilled";
+export declare const SNAPSHOT_STATE_UNFULFILLED = "Unfulfilled";
+export declare const snapshotRefreshOptions: {
+    overrides: {
+        headers: {
+            'Cache-Control': string;
+        };
+    };
+};
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+export declare function stableJSONStringify(node: any): string | undefined;
+export declare function getFetchResponseStatusText(status: number): string;
+export declare function isUnfulfilledSnapshot<T, U>(snapshot: $64$luvio_engine_Snapshot<T, U>): snapshot is $64$luvio_engine_UnfulfilledSnapshot<T, U>;
+export declare const keyPrefix = "assessment";

package/dist/types/src/generated/adapters/getAssessmentEnvelope.d.ts

@@ -0,0 +1,26 @@
+import { AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig, Untrusted as adapter$45$utils_Untrusted } from './adapter-utils';
+import { ResourceRequestConfig as resources_getConnectAssessmentsAssessmentenvelopes_ResourceRequestConfig } from '../resources/getConnectAssessmentsAssessmentenvelopes';
+import { Luvio as $64$luvio_engine_Luvio, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Fragment as $64$luvio_engine_Fragment, Snapshot as $64$luvio_engine_Snapshot, FetchResponse as $64$luvio_engine_FetchResponse, ErrorResponse as $64$luvio_engine_ErrorResponse, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, CoercedAdapterRequestContext as $64$luvio_engine_CoercedAdapterRequestContext, StoreLookup as $64$luvio_engine_StoreLookup, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { AssessmentEnvelopeGetResultRepresentation as types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation } from '../types/AssessmentEnvelopeGetResultRepresentation';
+export declare const adapterName = "getAssessmentEnvelope";
+export declare const getAssessmentEnvelope_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface GetAssessmentEnvelopeConfig {
+    signature?: string;
+}
+export declare function createResourceParams(config: GetAssessmentEnvelopeConfig): resources_getConnectAssessmentsAssessmentenvelopes_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetAssessmentEnvelopeConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: GetAssessmentEnvelopeConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetAssessmentEnvelopeConfig>): adapter$45$utils_Untrusted<GetAssessmentEnvelopeConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetAssessmentEnvelopeConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: GetAssessmentEnvelopeConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: GetAssessmentEnvelopeConfig): $64$luvio_engine_Snapshot<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: GetAssessmentEnvelopeConfig, resourceParams: resources_getConnectAssessmentsAssessmentenvelopes_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation>): Promise<import("@luvio/engine").PendingSnapshot<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation, any> | import("@luvio/engine").FulfilledSnapshot<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation, {}>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: GetAssessmentEnvelopeConfig, resourceParams: resources_getConnectAssessmentsAssessmentenvelopes_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetAssessmentEnvelopeConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: GetAssessmentEnvelopeConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation>): $64$luvio_engine_Snapshot<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation, any>;
+export declare const getAssessmentEnvelopeAdapterFactory: $64$luvio_engine_AdapterFactory<GetAssessmentEnvelopeConfig, types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation>;

package/dist/types/src/generated/adapters/postAssessmentContextSearch.d.ts

@@ -0,0 +1,16 @@
+import { AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig, Untrusted as adapter$45$utils_Untrusted } from './adapter-utils';
+import { AssessmentContextSearchInputRepresentation as types_AssessmentContextSearchInputRepresentation_AssessmentContextSearchInputRepresentation } from '../types/AssessmentContextSearchInputRepresentation';
+import { ResourceRequestConfig as resources_postConnectAssessmentsAssessmentElementsByContextId_ResourceRequestConfig } from '../resources/postConnectAssessmentsAssessmentElementsByContextId';
+import { Luvio as $64$luvio_engine_Luvio, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { AssessmentContextSearchResultRepresentation as types_AssessmentContextSearchResultRepresentation_AssessmentContextSearchResultRepresentation } from '../types/AssessmentContextSearchResultRepresentation';
+export declare const adapterName = "postAssessmentContextSearch";
+export declare const postAssessmentContextSearch_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface PostAssessmentContextSearchConfig {
+    contextId: string;
+    AssessmentContextSearchData: types_AssessmentContextSearchInputRepresentation_AssessmentContextSearchInputRepresentation;
+}
+export declare function createResourceParams(config: PostAssessmentContextSearchConfig): resources_postConnectAssessmentsAssessmentElementsByContextId_ResourceRequestConfig;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<PostAssessmentContextSearchConfig>): adapter$45$utils_Untrusted<PostAssessmentContextSearchConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): PostAssessmentContextSearchConfig | null;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: PostAssessmentContextSearchConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<import("@luvio/engine").FulfilledSnapshot<types_AssessmentContextSearchResultRepresentation_AssessmentContextSearchResultRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_AssessmentContextSearchResultRepresentation_AssessmentContextSearchResultRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_AssessmentContextSearchResultRepresentation_AssessmentContextSearchResultRepresentation, any>>;
+export declare const postAssessmentContextSearchAdapterFactory: $64$luvio_engine_AdapterFactory<PostAssessmentContextSearchConfig, types_AssessmentContextSearchResultRepresentation_AssessmentContextSearchResultRepresentation>;

package/dist/types/src/generated/adapters/postAssessmentEnvelope.d.ts

@@ -0,0 +1,15 @@
+import { AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig, Untrusted as adapter$45$utils_Untrusted } from './adapter-utils';
+import { AssessmentEnvelopeInputRepresentation as types_AssessmentEnvelopeInputRepresentation_AssessmentEnvelopeInputRepresentation } from '../types/AssessmentEnvelopeInputRepresentation';
+import { ResourceRequestConfig as resources_postConnectAssessmentsAssessmentenvelopes_ResourceRequestConfig } from '../resources/postConnectAssessmentsAssessmentenvelopes';
+import { Luvio as $64$luvio_engine_Luvio, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { AssessmentEnvelopeResultRepresentation as types_AssessmentEnvelopeResultRepresentation_AssessmentEnvelopeResultRepresentation } from '../types/AssessmentEnvelopeResultRepresentation';
+export declare const adapterName = "postAssessmentEnvelope";
+export declare const postAssessmentEnvelope_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface PostAssessmentEnvelopeConfig {
+    AssessmentEnvelopeData: types_AssessmentEnvelopeInputRepresentation_AssessmentEnvelopeInputRepresentation;
+}
+export declare function createResourceParams(config: PostAssessmentEnvelopeConfig): resources_postConnectAssessmentsAssessmentenvelopes_ResourceRequestConfig;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<PostAssessmentEnvelopeConfig>): adapter$45$utils_Untrusted<PostAssessmentEnvelopeConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): PostAssessmentEnvelopeConfig | null;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: PostAssessmentEnvelopeConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<import("@luvio/engine").FulfilledSnapshot<types_AssessmentEnvelopeResultRepresentation_AssessmentEnvelopeResultRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_AssessmentEnvelopeResultRepresentation_AssessmentEnvelopeResultRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_AssessmentEnvelopeResultRepresentation_AssessmentEnvelopeResultRepresentation, any>>;
+export declare const postAssessmentEnvelopeAdapterFactory: $64$luvio_engine_AdapterFactory<PostAssessmentEnvelopeConfig, types_AssessmentEnvelopeResultRepresentation_AssessmentEnvelopeResultRepresentation>;

package/dist/types/src/generated/artifacts/main.d.ts

@@ -0,0 +1,3 @@
+export { postAssessmentEnvelopeAdapterFactory } from '../adapters/postAssessmentEnvelope';
+export { getAssessmentEnvelopeAdapterFactory } from '../adapters/getAssessmentEnvelope';
+export { postAssessmentContextSearchAdapterFactory } from '../adapters/postAssessmentContextSearch';

package/dist/types/src/generated/artifacts/sfdc.d.ts

@@ -0,0 +1,5 @@
+declare let getAssessmentEnvelope: any;
+declare let postAssessmentContextSearch: any;
+declare let postAssessmentEnvelope: any;
+declare let getAssessmentEnvelope_imperative: any;
+export { getAssessmentEnvelope, postAssessmentContextSearch, postAssessmentEnvelope, getAssessmentEnvelope_imperative };

package/dist/types/src/generated/resources/getConnectAssessmentsAssessmentenvelopes.d.ts

@@ -0,0 +1,15 @@
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, FetchResponse as $64$luvio_engine_FetchResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ErrorResponse as $64$luvio_engine_ErrorResponse, ErrorSnapshot as $64$luvio_engine_ErrorSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { AssessmentEnvelopeGetResultRepresentation as types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation } from '../types/AssessmentEnvelopeGetResultRepresentation';
+export interface ResourceRequestConfig {
+    queryParams: {
+        signature?: string;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function getResponseCacheKeys(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation): $64$luvio_engine_DurableStoreKeyMetadataMap;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation, any>;
+export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_AssessmentEnvelopeGetResultRepresentation_AssessmentEnvelopeGetResultRepresentation>): $64$luvio_engine_ErrorSnapshot;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

package/dist/types/src/generated/resources/postConnectAssessmentsAssessmentElementsByContextId.d.ts

@@ -0,0 +1,16 @@
+import { AssessmentContextSearchInputRepresentation as types_AssessmentContextSearchInputRepresentation_AssessmentContextSearchInputRepresentation } from '../types/AssessmentContextSearchInputRepresentation';
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, FetchResponse as $64$luvio_engine_FetchResponse, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { AssessmentContextSearchResultRepresentation as types_AssessmentContextSearchResultRepresentation_AssessmentContextSearchResultRepresentation } from '../types/AssessmentContextSearchResultRepresentation';
+export interface ResourceRequestConfig {
+    urlParams: {
+        contextId: string;
+    };
+    body: {
+        AssessmentContextSearchData: types_AssessmentContextSearchInputRepresentation_AssessmentContextSearchInputRepresentation;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function getResponseCacheKeys(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_AssessmentContextSearchResultRepresentation_AssessmentContextSearchResultRepresentation): $64$luvio_engine_DurableStoreKeyMetadataMap;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_AssessmentContextSearchResultRepresentation_AssessmentContextSearchResultRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_AssessmentContextSearchResultRepresentation_AssessmentContextSearchResultRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_AssessmentContextSearchResultRepresentation_AssessmentContextSearchResultRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_AssessmentContextSearchResultRepresentation_AssessmentContextSearchResultRepresentation, any>;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

package/dist/types/src/generated/resources/postConnectAssessmentsAssessmentenvelopes.d.ts

@@ -0,0 +1,13 @@
+import { AssessmentEnvelopeInputRepresentation as types_AssessmentEnvelopeInputRepresentation_AssessmentEnvelopeInputRepresentation } from '../types/AssessmentEnvelopeInputRepresentation';
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, FetchResponse as $64$luvio_engine_FetchResponse, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { AssessmentEnvelopeResultRepresentation as types_AssessmentEnvelopeResultRepresentation_AssessmentEnvelopeResultRepresentation } from '../types/AssessmentEnvelopeResultRepresentation';
+export interface ResourceRequestConfig {
+    body: {
+        AssessmentEnvelopeData: types_AssessmentEnvelopeInputRepresentation_AssessmentEnvelopeInputRepresentation;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function getResponseCacheKeys(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_AssessmentEnvelopeResultRepresentation_AssessmentEnvelopeResultRepresentation): $64$luvio_engine_DurableStoreKeyMetadataMap;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_AssessmentEnvelopeResultRepresentation_AssessmentEnvelopeResultRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_AssessmentEnvelopeResultRepresentation_AssessmentEnvelopeResultRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_AssessmentEnvelopeResultRepresentation_AssessmentEnvelopeResultRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_AssessmentEnvelopeResultRepresentation_AssessmentEnvelopeResultRepresentation, any>;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

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

@@ -0,0 +1,41 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "b2f184e5bfa383b853a781f77ced5876";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: AssessmentContextSearchInputRepresentation, existing: AssessmentContextSearchInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): AssessmentContextSearchInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: AssessmentContextSearchInputRepresentationNormalized, incoming: AssessmentContextSearchInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: AssessmentContextSearchInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: AssessmentContextSearchInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Assessment context search input
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentContextSearchInputRepresentationNormalized {
+    /** List of Derived Filters that needs to be used to fetch Data */
+    derivedFilters: Array<{}>;
+    /** List of filter criteria to be applied. */
+    filterCriteria: Array<{}>;
+    /** Number of records to return.  Defaults to 20 records. */
+    recordCount: number | null;
+    /** List of record offsets. */
+    recordOffsets: Array<{}>;
+    /** List of sort options in the order the resultset needs to be sorted. */
+    sortOptions: Array<{}>;
+}
+/**
+ * Assessment context search input
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentContextSearchInputRepresentation {
+    derivedFilters: Array<{}>;
+    filterCriteria: Array<{}>;
+    recordCount: number | null;
+    recordOffsets: Array<{}>;
+    sortOptions: Array<{}>;
+}

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

@@ -0,0 +1,52 @@
+import { RecordOffsetRepresentation as RecordOffsetRepresentation_RecordOffsetRepresentation } from './RecordOffsetRepresentation';
+import { RecordsRepresentation as RecordsRepresentation_RecordsRepresentation } from './RecordsRepresentation';
+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, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "c1956ceb39431373785587564063205e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    isSuccess: boolean;
+}
+export type AssessmentContextSearchResultRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialAssessmentContextSearchResultRepresentationNormalizedKeyMetadata = 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): AssessmentContextSearchResultRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: AssessmentContextSearchResultRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: AssessmentContextSearchResultRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: AssessmentContextSearchResultRepresentation, existing: AssessmentContextSearchResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): AssessmentContextSearchResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: AssessmentContextSearchResultRepresentationNormalized, incoming: AssessmentContextSearchResultRepresentationNormalized): boolean;
+export declare function deepFreeze(input: AssessmentContextSearchResultRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: AssessmentContextSearchResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Assessment search completed successfully.
+ *
+ * Keys:
+ *    isSuccess (boolean): isSuccess
+ */
+export interface AssessmentContextSearchResultRepresentationNormalized {
+    /** true if there are more records to fetch.  false if it is the last page. */
+    hasMoreRecords: boolean;
+    /** true if successful and false if there is a failure */
+    isSuccess: boolean;
+    /** If isSuccess is false, there can be one or more error messages.  If isSuccess is true, message will be empty. */
+    message: string | null;
+    /** List of record offsets based on which the records were queried.  The offsets are returned back to the client for the client to provide this information next time to get subsequent pages. */
+    recordOffsets: Array<RecordOffsetRepresentation_RecordOffsetRepresentation>;
+    /** List of records returned back by the API */
+    records: Array<RecordsRepresentation_RecordsRepresentation>;
+}
+/**
+ * Assessment search completed successfully.
+ *
+ * Keys:
+ *    isSuccess (boolean): isSuccess
+ */
+export interface AssessmentContextSearchResultRepresentation {
+    hasMoreRecords: boolean;
+    isSuccess: boolean;
+    message: string | null;
+    recordOffsets: Array<RecordOffsetRepresentation_RecordOffsetRepresentation>;
+    records: Array<RecordsRepresentation_RecordsRepresentation>;
+}

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

@@ -0,0 +1,30 @@
+import { AssessmentContextSearchInputRepresentation as AssessmentContextSearchInputRepresentation_AssessmentContextSearchInputRepresentation } from './AssessmentContextSearchInputRepresentation';
+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 = "7eda284efea68282f4916386ea43eb17";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: AssessmentContextSearchWrapperInputRepresentation, existing: AssessmentContextSearchWrapperInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): AssessmentContextSearchWrapperInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: AssessmentContextSearchWrapperInputRepresentationNormalized, incoming: AssessmentContextSearchWrapperInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: AssessmentContextSearchWrapperInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: AssessmentContextSearchWrapperInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * wrapper of AssessmentContextSearchInputRepresentation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentContextSearchWrapperInputRepresentationNormalized {
+    /** Input representation for AssessmentContextSearchInputRepresentation */
+    AssessmentContextSearchData: AssessmentContextSearchInputRepresentation_AssessmentContextSearchInputRepresentation;
+}
+/**
+ * wrapper of AssessmentContextSearchInputRepresentation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentContextSearchWrapperInputRepresentation {
+    AssessmentContextSearchData: AssessmentContextSearchInputRepresentation_AssessmentContextSearchInputRepresentation;
+}

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

@@ -0,0 +1,36 @@
+import { AssessmentEnvelopeOutputRepresentation as AssessmentEnvelopeOutputRepresentation_AssessmentEnvelopeOutputRepresentation } from './AssessmentEnvelopeOutputRepresentation';
+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 = 6000;
+export declare const VERSION = "7b60ad6d5543265bc7066c36ff3987e4";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: AssessmentEnvelopeGetResultRepresentation, existing: AssessmentEnvelopeGetResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): AssessmentEnvelopeGetResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: AssessmentEnvelopeGetResultRepresentationNormalized, incoming: AssessmentEnvelopeGetResultRepresentationNormalized): boolean;
+export declare function deepFreeze(input: AssessmentEnvelopeGetResultRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: AssessmentEnvelopeGetResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of Assessment envelope from the GET Resource
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeGetResultRepresentationNormalized {
+    assessmentEnvelope?: AssessmentEnvelopeOutputRepresentation_AssessmentEnvelopeOutputRepresentation;
+    /** true if successful and false if there is a failure */
+    isSuccess: boolean;
+    /** If isSuccess is false, there can be one or more error messages.  If isSuccess is true, message will be empty. */
+    message: string;
+}
+/**
+ * Output representation of Assessment envelope from the GET Resource
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeGetResultRepresentation {
+    assessmentEnvelope?: AssessmentEnvelopeOutputRepresentation_AssessmentEnvelopeOutputRepresentation;
+    isSuccess: boolean;
+    message: string;
+}

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

@@ -0,0 +1,47 @@
+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 = "5cf1fc9081296b4561a5509031e6e67d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: AssessmentEnvelopeInputRepresentation, existing: AssessmentEnvelopeInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): AssessmentEnvelopeInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: AssessmentEnvelopeInputRepresentationNormalized, incoming: AssessmentEnvelopeInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: AssessmentEnvelopeInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: AssessmentEnvelopeInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Assessment envelope input
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeInputRepresentationNormalized {
+    /** Account of the assessment envelope */
+    account?: string | null;
+    /** List of assessment envelope items associated to the assessment envelope */
+    assessmentEnvelopeItems: Array<{}>;
+    /** Contact of the assessment envelope */
+    contact?: string | null;
+    /** Expiration datetime of the assessment envelope */
+    expirationDateTime: string | null;
+    /** Name of the assessment envelope */
+    name: string | null;
+    /** Request context of the assessment envelope */
+    requestReference?: string | null;
+    /** Status of the assessment envelope */
+    status: string | null;
+}
+/**
+ * Assessment envelope input
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeInputRepresentation {
+    account?: string | null;
+    assessmentEnvelopeItems: Array<{}>;
+    contact?: string | null;
+    expirationDateTime: string | null;
+    name: string | null;
+    requestReference?: string | null;
+    status: string | null;
+}

package/dist/types/src/generated/types/AssessmentEnvelopeItemsListOutputRepresentation.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 = "ec192e663e759eae8b07e2a22f6b1d49";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: AssessmentEnvelopeItemsListOutputRepresentation, existing: AssessmentEnvelopeItemsListOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): AssessmentEnvelopeItemsListOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: AssessmentEnvelopeItemsListOutputRepresentationNormalized, incoming: AssessmentEnvelopeItemsListOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: AssessmentEnvelopeItemsListOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: AssessmentEnvelopeItemsListOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of list of assessment envelope items
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeItemsListOutputRepresentationNormalized {
+    /** Assessment envelope item record id */
+    id?: string;
+    /** Assessment envelope item omniprocess */
+    omniProcessId?: string;
+    /** Assessment envelope item status */
+    status: string;
+}
+/**
+ * Output representation of list of assessment envelope items
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeItemsListOutputRepresentation {
+    id?: string;
+    omniProcessId?: string;
+    status: string;
+}

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

@@ -0,0 +1,29 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "a3782c06460d6c648c725cfab29d83b3";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: AssessmentEnvelopeItemsListRepresentation, existing: AssessmentEnvelopeItemsListRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): AssessmentEnvelopeItemsListRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: AssessmentEnvelopeItemsListRepresentationNormalized, incoming: AssessmentEnvelopeItemsListRepresentationNormalized): boolean;
+export declare function deepFreeze(input: AssessmentEnvelopeItemsListRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: AssessmentEnvelopeItemsListRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * List of assessment envelope items
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeItemsListRepresentationNormalized {
+    /** Assessment envelope item record id */
+    id: string | null;
+}
+/**
+ * List of assessment envelope items
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeItemsListRepresentation {
+    id: string | null;
+}

package/dist/types/src/generated/types/AssessmentEnvelopeItemsRepresentation.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 = "fc8dcf66efb20af80295cda1b0855350";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: AssessmentEnvelopeItemsRepresentation, existing: AssessmentEnvelopeItemsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): AssessmentEnvelopeItemsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: AssessmentEnvelopeItemsRepresentationNormalized, incoming: AssessmentEnvelopeItemsRepresentationNormalized): boolean;
+export declare function deepFreeze(input: AssessmentEnvelopeItemsRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: AssessmentEnvelopeItemsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * List of assessment envelope items associated to the assessment envelope
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeItemsRepresentationNormalized {
+    /** Name of the assessment envelope item */
+    name: string | null;
+    /** OmniProcess record id of the assessment envelope item */
+    omniProcess: string | null;
+    /** Status of the assessment envelope item */
+    status: string | null;
+}
+/**
+ * List of assessment envelope items associated to the assessment envelope
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeItemsRepresentation {
+    name: string | null;
+    omniProcess: string | null;
+    status: string | null;
+}

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

@@ -0,0 +1,39 @@
+import { AssessmentEnvelopeItemsListOutputRepresentation as AssessmentEnvelopeItemsListOutputRepresentation_AssessmentEnvelopeItemsListOutputRepresentation } from './AssessmentEnvelopeItemsListOutputRepresentation';
+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 = "2d6c83ce89935207ed4896dda9b4d27b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: AssessmentEnvelopeOutputRepresentation, existing: AssessmentEnvelopeOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): AssessmentEnvelopeOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: AssessmentEnvelopeOutputRepresentationNormalized, incoming: AssessmentEnvelopeOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: AssessmentEnvelopeOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: AssessmentEnvelopeOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of Assessment envelope from the GET Resource
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeOutputRepresentationNormalized {
+    /** List of assessment envelope items */
+    assessmentEnvelopeItems?: Array<AssessmentEnvelopeItemsListOutputRepresentation_AssessmentEnvelopeItemsListOutputRepresentation>;
+    /** Assessment envelope expiration datetime */
+    expirationDateTime?: string;
+    /** Assessment envelope record id */
+    id?: string;
+    /** Assessment envelope status */
+    status: string;
+}
+/**
+ * Output representation of Assessment envelope from the GET Resource
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeOutputRepresentation {
+    assessmentEnvelopeItems?: Array<AssessmentEnvelopeItemsListOutputRepresentation_AssessmentEnvelopeItemsListOutputRepresentation>;
+    expirationDateTime?: string;
+    id?: string;
+    status: string;
+}

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

@@ -0,0 +1,33 @@
+import { AssessmentEnvelopeItemsListRepresentation as AssessmentEnvelopeItemsListRepresentation_AssessmentEnvelopeItemsListRepresentation } from './AssessmentEnvelopeItemsListRepresentation';
+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 = "ab49eca219417dfaf0dd968d35ce3b21";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: AssessmentEnvelopeRepresentation, existing: AssessmentEnvelopeRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): AssessmentEnvelopeRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: AssessmentEnvelopeRepresentationNormalized, incoming: AssessmentEnvelopeRepresentationNormalized): boolean;
+export declare function deepFreeze(input: AssessmentEnvelopeRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: AssessmentEnvelopeRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Assessment envelope response
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeRepresentationNormalized {
+    /** List of assessment envelope items */
+    assessmentEnvelopeItems: Array<AssessmentEnvelopeItemsListRepresentation_AssessmentEnvelopeItemsListRepresentation>;
+    /** Assessment envelope record id */
+    id: string | null;
+}
+/**
+ * Assessment envelope response
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AssessmentEnvelopeRepresentation {
+    assessmentEnvelopeItems: Array<AssessmentEnvelopeItemsListRepresentation_AssessmentEnvelopeItemsListRepresentation>;
+    id: string | null;
+}