@salesforce/lds-adapters-industries-identityverification 1.100.2

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

@@ -0,0 +1,32 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "8f333fda3c43cdf36ba827cd2fb1fdf3";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: TimelineErrorRepresentation, existing: TimelineErrorRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): TimelineErrorRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: TimelineErrorRepresentationNormalized, incoming: TimelineErrorRepresentationNormalized): boolean;
+export declare function deepFreeze(input: TimelineErrorRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: TimelineErrorRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Error response representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineErrorRepresentationNormalized {
+    /** Code for Error */
+    code: string;
+    /** Message Error */
+    message: string;
+}
+/**
+ * Error response representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineErrorRepresentation {
+    code: string;
+    message: string;
+}

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

@@ -0,0 +1,32 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "7376c6f860d705950f87d03cda21ae03";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: TimelineEventFieldRepresentation, existing: TimelineEventFieldRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): TimelineEventFieldRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: TimelineEventFieldRepresentationNormalized, incoming: TimelineEventFieldRepresentationNormalized): boolean;
+export declare function deepFreeze(input: TimelineEventFieldRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: TimelineEventFieldRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of the Event Field that is returned as part of the GET Timeline Data Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineEventFieldRepresentationNormalized {
+    /** Event Field Name */
+    name: string;
+    /** Event Field Value */
+    value: string;
+}
+/**
+ * Output representation of the Event Field that is returned as part of the GET Timeline Data Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineEventFieldRepresentation {
+    name: string;
+    value: string;
+}

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

@@ -0,0 +1,45 @@
+import { TimelineEventFieldRepresentation as TimelineEventFieldRepresentation_TimelineEventFieldRepresentation } from './TimelineEventFieldRepresentation';
+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 = "80a3058efd8d37fb9e7e51fb7d656b00";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: TimelineEventRepresentation, existing: TimelineEventRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): TimelineEventRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: TimelineEventRepresentationNormalized, incoming: TimelineEventRepresentationNormalized): boolean;
+export declare function deepFreeze(input: TimelineEventRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: TimelineEventRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of the Event that is returned as part of the GET Timeline Data Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineEventRepresentationNormalized {
+    /** Description of the Event Entity */
+    description: string;
+    /** Date Time of the Event */
+    eventDateTime: string;
+    /** Fields of the Event */
+    fields: Array<TimelineEventFieldRepresentation_TimelineEventFieldRepresentation>;
+    /** Record Id */
+    id: string;
+    /** Title of the Event Entity */
+    title: string;
+    /** Event Entity Type */
+    type: string;
+}
+/**
+ * Output representation of the Event that is returned as part of the GET Timeline Data Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineEventRepresentation {
+    description: string;
+    eventDateTime: string;
+    fields: Array<TimelineEventFieldRepresentation_TimelineEventFieldRepresentation>;
+    id: string;
+    title: string;
+    type: string;
+}

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

@@ -0,0 +1,54 @@
+import { TimelineElementRepresentation as TimelineElementRepresentation_TimelineElementRepresentation } from './TimelineElementRepresentation';
+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 = "c5c3afdc6b6ffbcfdbd96ff675089df4";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: TimelineEventTypeMetadataRepresentation, existing: TimelineEventTypeMetadataRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): TimelineEventTypeMetadataRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: TimelineEventTypeMetadataRepresentationNormalized, incoming: TimelineEventTypeMetadataRepresentationNormalized): boolean;
+export declare function deepFreeze(input: TimelineEventTypeMetadataRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: TimelineEventTypeMetadataRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of Event Object that is returned as part of the GET Timeline metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineEventTypeMetadataRepresentationNormalized {
+    /** Event Object anchor Reference field */
+    anchorReferenceField: TimelineElementRepresentation_TimelineElementRepresentation;
+    /** Event Entity API Name */
+    entityApiName: string;
+    /** Event Entity Label Name */
+    entityLabel: string;
+    /** Event Object fieldsToDisplay List */
+    fieldsToDisplay: Array<TimelineElementRepresentation_TimelineElementRepresentation>;
+    /** Event Object relatedlistsToDisplay List */
+    relatedlistsToDisplay: Array<TimelineElementRepresentation_TimelineElementRepresentation>;
+    /** Event Object relation type */
+    relationType: string;
+    /** Event Object sort field */
+    sortField: TimelineElementRepresentation_TimelineElementRepresentation;
+    /** Event Object subTitle field */
+    subTitle: TimelineElementRepresentation_TimelineElementRepresentation;
+    /** Event Object title field */
+    title: TimelineElementRepresentation_TimelineElementRepresentation;
+}
+/**
+ * Output representation of Event Object that is returned as part of the GET Timeline metadata
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineEventTypeMetadataRepresentation {
+    anchorReferenceField: TimelineElementRepresentation_TimelineElementRepresentation;
+    entityApiName: string;
+    entityLabel: string;
+    fieldsToDisplay: Array<TimelineElementRepresentation_TimelineElementRepresentation>;
+    relatedlistsToDisplay: Array<TimelineElementRepresentation_TimelineElementRepresentation>;
+    relationType: string;
+    sortField: TimelineElementRepresentation_TimelineElementRepresentation;
+    subTitle: TimelineElementRepresentation_TimelineElementRepresentation;
+    title: TimelineElementRepresentation_TimelineElementRepresentation;
+}

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

@@ -0,0 +1,32 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "cd912fd3890ffef3507e1cd88ba51b55";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: TimelineEventTypeRepresentation, existing: TimelineEventTypeRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): TimelineEventTypeRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: TimelineEventTypeRepresentationNormalized, incoming: TimelineEventTypeRepresentationNormalized): boolean;
+export declare function deepFreeze(input: TimelineEventTypeRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: TimelineEventTypeRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of EventType that is returned as part of the GET Timeline Data Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineEventTypeRepresentationNormalized {
+    /** Event API Name */
+    eventApiName: string;
+    /** Timeline Data Offset */
+    offset: number;
+}
+/**
+ * Output representation of EventType that is returned as part of the GET Timeline Data Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineEventTypeRepresentation {
+    eventApiName: string;
+    offset: number;
+}

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

@@ -0,0 +1,43 @@
+import { TimelineEntityRepresentation as TimelineEntityRepresentation_TimelineEntityRepresentation } from './TimelineEntityRepresentation';
+import { TimelineEventTypeMetadataRepresentation as TimelineEventTypeMetadataRepresentation_TimelineEventTypeMetadataRepresentation } from './TimelineEventTypeMetadataRepresentation';
+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 = "4d45a66a41112464bb69a8aab604fec9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: TimelineMetadataDefinitionRepresentation, existing: TimelineMetadataDefinitionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): TimelineMetadataDefinitionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: TimelineMetadataDefinitionRepresentationNormalized, incoming: TimelineMetadataDefinitionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: TimelineMetadataDefinitionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: TimelineMetadataDefinitionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of Timeline Metadata from the GET Resource
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineMetadataDefinitionRepresentationNormalized {
+    /** TimelineMetadata Anchor Object */
+    anchorObject: TimelineEntityRepresentation_TimelineEntityRepresentation;
+    /** TimelineMetadata GET Resource fetch all event objects */
+    eventTypes: Array<TimelineEventTypeMetadataRepresentation_TimelineEventTypeMetadataRepresentation>;
+    /** TimelineMetadata Configuration Name */
+    fullName: string;
+    /** TimelineMetadata active status flag */
+    isActive: boolean;
+    /** TimelineMetadata Configuration Label */
+    masterLabel: string;
+}
+/**
+ * Output representation of Timeline Metadata from the GET Resource
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineMetadataDefinitionRepresentation {
+    anchorObject: TimelineEntityRepresentation_TimelineEntityRepresentation;
+    eventTypes: Array<TimelineEventTypeMetadataRepresentation_TimelineEventTypeMetadataRepresentation>;
+    fullName: string;
+    isActive: boolean;
+    masterLabel: string;
+}

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

@@ -0,0 +1,37 @@
+import { TimelineMetadataDefinitionRepresentation as TimelineMetadataDefinitionRepresentation_TimelineMetadataDefinitionRepresentation } from './TimelineMetadataDefinitionRepresentation';
+import { TimelineErrorRepresentation as TimelineErrorRepresentation_TimelineErrorRepresentation } from './TimelineErrorRepresentation';
+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 = "c88899f84d39b06f5827e7afa72392c7";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: TimelineMetadataResultRepresentation, existing: TimelineMetadataResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): TimelineMetadataResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: TimelineMetadataResultRepresentationNormalized, incoming: TimelineMetadataResultRepresentationNormalized): boolean;
+export declare function deepFreeze(input: TimelineMetadataResultRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: TimelineMetadataResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of Timeline Metadata from the GET Resource
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineMetadataResultRepresentationNormalized {
+    /** TimelineMetadata GET Resource fetch all definitions */
+    definitions: Array<TimelineMetadataDefinitionRepresentation_TimelineMetadataDefinitionRepresentation>;
+    /** TimelineMetadata GET Resource List of Errors */
+    errors: Array<TimelineErrorRepresentation_TimelineErrorRepresentation>;
+    /** TimelineMetadata get status */
+    status: string;
+}
+/**
+ * Output representation of Timeline Metadata from the GET Resource
+ *
+ * Keys:
+ *    (none)
+ */
+export interface TimelineMetadataResultRepresentation {
+    definitions: Array<TimelineMetadataDefinitionRepresentation_TimelineMetadataDefinitionRepresentation>;
+    errors: Array<TimelineErrorRepresentation_TimelineErrorRepresentation>;
+    status: string;
+}

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

@@ -0,0 +1,32 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "2a936f9d3e6c3f9d07a49fa3622d5811";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: UpdateVideoCallInputRepresentation, existing: UpdateVideoCallInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): UpdateVideoCallInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: UpdateVideoCallInputRepresentationNormalized, incoming: UpdateVideoCallInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: UpdateVideoCallInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: UpdateVideoCallInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for UpdateVideoCall
+ *
+ * Keys:
+ *    (none)
+ */
+export interface UpdateVideoCallInputRepresentationNormalized {
+    /** Set whether Video Call is ended or not */
+    isEnded: boolean;
+    /** Set Meeting Id for Video Call update */
+    meetingId: string;
+}
+/**
+ * Input representation for UpdateVideoCall
+ *
+ * Keys:
+ *    (none)
+ */
+export interface UpdateVideoCallInputRepresentation {
+    isEnded: boolean;
+    meetingId: string;
+}

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

@@ -0,0 +1,32 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "9cbbf8f734535884332756cf1d2e2c64";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: UpdateVideoCallResultRepresentation, existing: UpdateVideoCallResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): UpdateVideoCallResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: UpdateVideoCallResultRepresentationNormalized, incoming: UpdateVideoCallResultRepresentationNormalized): boolean;
+export declare function deepFreeze(input: UpdateVideoCallResultRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: UpdateVideoCallResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of UpdateVideoCall Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface UpdateVideoCallResultRepresentationNormalized {
+    /** UpdateVideoCall error messages */
+    errorMessage?: string;
+    /** UpdateVideoCall success flag */
+    isSuccess: boolean;
+}
+/**
+ * Output representation of UpdateVideoCall Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface UpdateVideoCallResultRepresentation {
+    errorMessage?: string;
+    isSuccess: boolean;
+}

package/dist/types/src/generated/types/ValidateSignatureInputRepresentation.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 = "1f772b12333fefba770dc555a95ab4bd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ValidateSignatureInputRepresentation, existing: ValidateSignatureInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ValidateSignatureInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ValidateSignatureInputRepresentationNormalized, incoming: ValidateSignatureInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ValidateSignatureInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ValidateSignatureInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for ValidateSignature
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ValidateSignatureInputRepresentationNormalized {
+    /** The signature to be validated */
+    signature: string;
+}
+/**
+ * Input representation for ValidateSignature
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ValidateSignatureInputRepresentation {
+    signature: string;
+}

package/dist/types/src/generated/types/ValidateSignatureResultRepresentation.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 = "b94ce95c9a5575ebe49c8371f2f2be97";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ValidateSignatureResultRepresentation, existing: ValidateSignatureResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ValidateSignatureResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ValidateSignatureResultRepresentationNormalized, incoming: ValidateSignatureResultRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ValidateSignatureResultRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ValidateSignatureResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of ValidateSignature
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ValidateSignatureResultRepresentationNormalized {
+    /** ValidateSignature error messages */
+    errorMessage?: string;
+    /** The external meeting id for the supplied signature */
+    externalMeetingId?: string;
+    /** ValidateSignature valid flag */
+    isValid: boolean;
+}
+/**
+ * Output representation of ValidateSignature
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ValidateSignatureResultRepresentation {
+    errorMessage?: string;
+    externalMeetingId?: string;
+    isValid: boolean;
+}

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

@@ -0,0 +1,41 @@
+import { ProcessDefinitionInputRepresentation as ProcessDefinitionInputRepresentation_ProcessDefinitionInputRepresentation } from './ProcessDefinitionInputRepresentation';
+import { SelectedSearchResultInputRepresentation as SelectedSearchResultInputRepresentation_SelectedSearchResultInputRepresentation } from './SelectedSearchResultInputRepresentation';
+import { SelectedVerifiedResultInputRepresentation as SelectedVerifiedResultInputRepresentation_SelectedVerifiedResultInputRepresentation } from './SelectedVerifiedResultInputRepresentation';
+import { VerifiedResultInputRepresentation as VerifiedResultInputRepresentation_VerifiedResultInputRepresentation } from './VerifiedResultInputRepresentation';
+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 = "9f49b4f656c3c17873bee11bc7505cb9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: VerificationContextInputRepresentation, existing: VerificationContextInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): VerificationContextInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: VerificationContextInputRepresentationNormalized, incoming: VerificationContextInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: VerificationContextInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: VerificationContextInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for verification context
+ *
+ * Keys:
+ *    (none)
+ */
+export interface VerificationContextInputRepresentationNormalized {
+    /** Process Definition */
+    processDefinition: ProcessDefinitionInputRepresentation_ProcessDefinitionInputRepresentation;
+    /** Selected Search Result */
+    selectedSearchResult: SelectedSearchResultInputRepresentation_SelectedSearchResultInputRepresentation;
+    /** Selected Verified Result */
+    selectedVerifiedResult: SelectedVerifiedResultInputRepresentation_SelectedVerifiedResultInputRepresentation;
+    verifiedResult: VerifiedResultInputRepresentation_VerifiedResultInputRepresentation;
+}
+/**
+ * Input representation for verification context
+ *
+ * Keys:
+ *    (none)
+ */
+export interface VerificationContextInputRepresentation {
+    processDefinition: ProcessDefinitionInputRepresentation_ProcessDefinitionInputRepresentation;
+    selectedSearchResult: SelectedSearchResultInputRepresentation_SelectedSearchResultInputRepresentation;
+    selectedVerifiedResult: SelectedVerifiedResultInputRepresentation_SelectedVerifiedResultInputRepresentation;
+    verifiedResult: VerifiedResultInputRepresentation_VerifiedResultInputRepresentation;
+}

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

@@ -0,0 +1,57 @@
+import { ProcessDefinitionOutputRepresentation as ProcessDefinitionOutputRepresentation_ProcessDefinitionOutputRepresentation } from './ProcessDefinitionOutputRepresentation';
+import { SelectedSearchResultOutputRepresentation as SelectedSearchResultOutputRepresentation_SelectedSearchResultOutputRepresentation } from './SelectedSearchResultOutputRepresentation';
+import { SelectedVerifiedResultOutputRepresentation as SelectedVerifiedResultOutputRepresentation_SelectedVerifiedResultOutputRepresentation } from './SelectedVerifiedResultOutputRepresentation';
+import { VerifiedResultOutputRepresentation as VerifiedResultOutputRepresentation_VerifiedResultOutputRepresentation } from './VerifiedResultOutputRepresentation';
+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 TTL = 300;
+export declare const VERSION = "4f545b10a56df76ef87654b567d69cd6";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    message: string;
+}
+export type VerificationContextOutputRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialVerificationContextOutputRepresentationNormalizedKeyMetadata = 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): VerificationContextOutputRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: VerificationContextOutputRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: VerificationContextOutputRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: VerificationContextOutputRepresentation, existing: VerificationContextOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): VerificationContextOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: VerificationContextOutputRepresentationNormalized, incoming: VerificationContextOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: VerificationContextOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: VerificationContextOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Representation of Verification Context
+ *
+ * Keys:
+ *    message (string): message
+ */
+export interface VerificationContextOutputRepresentationNormalized {
+    /** API result success/failure */
+    isSuccess: boolean;
+    /** API result message */
+    message: string;
+    /** Process Definition */
+    processDefinition: ProcessDefinitionOutputRepresentation_ProcessDefinitionOutputRepresentation;
+    /** Selected Search Result */
+    selectedSearchResult: SelectedSearchResultOutputRepresentation_SelectedSearchResultOutputRepresentation;
+    /** Selected Verified Result */
+    selectedVerifiedResult: SelectedVerifiedResultOutputRepresentation_SelectedVerifiedResultOutputRepresentation;
+    verifiedResult: VerifiedResultOutputRepresentation_VerifiedResultOutputRepresentation;
+}
+/**
+ * Representation of Verification Context
+ *
+ * Keys:
+ *    message (string): message
+ */
+export interface VerificationContextOutputRepresentation {
+    isSuccess: boolean;
+    message: string;
+    processDefinition: ProcessDefinitionOutputRepresentation_ProcessDefinitionOutputRepresentation;
+    selectedSearchResult: SelectedSearchResultOutputRepresentation_SelectedSearchResultOutputRepresentation;
+    selectedVerifiedResult: SelectedVerifiedResultOutputRepresentation_SelectedVerifiedResultOutputRepresentation;
+    verifiedResult: VerifiedResultOutputRepresentation_VerifiedResultOutputRepresentation;
+}

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

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

package/dist/types/src/generated/types/VerificationProcessFieldInputRepresentation.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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "1e514ec52eec6691418da4a710177c01";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: VerificationProcessFieldInputRepresentation, existing: VerificationProcessFieldInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): VerificationProcessFieldInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: VerificationProcessFieldInputRepresentationNormalized, incoming: VerificationProcessFieldInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: VerificationProcessFieldInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: VerificationProcessFieldInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for verification process field
+ *
+ * Keys:
+ *    (none)
+ */
+export interface VerificationProcessFieldInputRepresentationNormalized {
+    /** Data Source Type - Salesforce/External */
+    dataSourceType: string;
+    /** Data type */
+    dataType: string;
+    /** Developer Name */
+    developerName: string;
+    /** Field Name */
+    fieldName: string;
+    /** Field Type */
+    fieldType: string;
+    /** Field Value Formula */
+    fieldValueFormula: string;
+    /** Is Manual Input */
+    isManualInput: boolean;
+    /** Label value */
+    label: string;
+}
+/**
+ * Input representation for verification process field
+ *
+ * Keys:
+ *    (none)
+ */
+export interface VerificationProcessFieldInputRepresentation {
+    dataSourceType: string;
+    dataType: string;
+    developerName: string;
+    fieldName: string;
+    fieldType: string;
+    fieldValueFormula: string;
+    isManualInput: boolean;
+    label: string;
+}

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

@@ -0,0 +1,30 @@
+import { VerificationProcessFieldInputRepresentation as VerificationProcessFieldInputRepresentation_VerificationProcessFieldInputRepresentation } from './VerificationProcessFieldInputRepresentation';
+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 = "30466c30399b074091be79e69c98e328";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: VerificationProcessFieldListInputRepresentation, existing: VerificationProcessFieldListInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): VerificationProcessFieldListInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: VerificationProcessFieldListInputRepresentationNormalized, incoming: VerificationProcessFieldListInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: VerificationProcessFieldListInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: VerificationProcessFieldListInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation for list of verification process field
+ *
+ * Keys:
+ *    (none)
+ */
+export interface VerificationProcessFieldListInputRepresentationNormalized {
+    /** List of verificationProcessField */
+    verificationProcessFields: Array<VerificationProcessFieldInputRepresentation_VerificationProcessFieldInputRepresentation>;
+}
+/**
+ * Input representation for list of verification process field
+ *
+ * Keys:
+ *    (none)
+ */
+export interface VerificationProcessFieldListInputRepresentation {
+    verificationProcessFields: Array<VerificationProcessFieldInputRepresentation_VerificationProcessFieldInputRepresentation>;
+}