@salesforce/lds-adapters-industries-docgen 1.100.2

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

@@ -0,0 +1,31 @@
+import { ClauseCategoryResponse as ClauseCategoryResponse_ClauseCategoryResponse } from './ClauseCategoryResponse';
+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 TTL = 30000;
+export declare const VERSION = "6f04ab6a782443d237ece40b87b8d756";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ClauseCategoriesResponse, existing: ClauseCategoriesResponseNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ClauseCategoriesResponseNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ClauseCategoriesResponseNormalized, incoming: ClauseCategoriesResponseNormalized): boolean;
+export declare function deepFreeze(input: ClauseCategoriesResponse): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ClauseCategoriesResponse, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * API Response Representation for Getting Clause Lib Category Config
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ClauseCategoriesResponseNormalized {
+    /** This attribute is for list of category config */
+    clauseCategories: Array<ClauseCategoryResponse_ClauseCategoryResponse>;
+}
+/**
+ * API Response Representation for Getting Clause Lib Category Config
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ClauseCategoriesResponse {
+    clauseCategories: Array<ClauseCategoryResponse_ClauseCategoryResponse>;
+}

package/dist/types/src/generated/types/ClauseCategoryResponse.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 = "c0cdffc7d0ce780dd3dbd6844cb94df8";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ClauseCategoryResponse, existing: ClauseCategoryResponseNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ClauseCategoryResponseNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ClauseCategoryResponseNormalized, incoming: ClauseCategoryResponseNormalized): boolean;
+export declare function deepFreeze(input: ClauseCategoryResponse): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ClauseCategoryResponse, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * API Response Representation for Field Level info for clause category
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ClauseCategoryResponseNormalized {
+    /** This attribute contains Id for custom clause config */
+    id?: string;
+    /** This attribute contains name for clause config */
+    name: string;
+    /** This attribute contains usageType for clause config */
+    usageType: string;
+}
+/**
+ * API Response Representation for Field Level info for clause category
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ClauseCategoryResponse {
+    id?: string;
+    name: string;
+    usageType: string;
+}

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

@@ -0,0 +1,33 @@
+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 TTL = 100;
+export declare const VERSION = "a3afe2a67715551a49f0d59eafb639aa";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DocumentClauseFieldsResponse, existing: DocumentClauseFieldsResponseNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DocumentClauseFieldsResponseNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DocumentClauseFieldsResponseNormalized, incoming: DocumentClauseFieldsResponseNormalized): boolean;
+export declare function deepFreeze(input: DocumentClauseFieldsResponse): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DocumentClauseFieldsResponse, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output Representation for List of Document Clause Fields
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentClauseFieldsResponseNormalized {
+    /** Document Clause fields value based on field Name parameter */
+    extendedFields: unknown;
+    /** Document Clause fields value based on field Name parameter */
+    fieldValues: Array<string>;
+}
+/**
+ * Output Representation for List of Document Clause Fields
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentClauseFieldsResponse {
+    extendedFields: unknown;
+    fieldValues: Array<string>;
+}

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

@@ -0,0 +1,31 @@
+import { DocumentClauseSetResponse as DocumentClauseSetResponse_DocumentClauseSetResponse } from './DocumentClauseSetResponse';
+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 TTL = 100;
+export declare const VERSION = "c6ad1fbdbd4d8cd718a8a62c63216687";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DocumentClauseSetListResponse, existing: DocumentClauseSetListResponseNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DocumentClauseSetListResponseNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DocumentClauseSetListResponseNormalized, incoming: DocumentClauseSetListResponseNormalized): boolean;
+export declare function deepFreeze(input: DocumentClauseSetListResponse): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DocumentClauseSetListResponse, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output Representation for List of Clause Set
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentClauseSetListResponseNormalized {
+    /** List of Document Clause Set */
+    documentClauseSets: Array<DocumentClauseSetResponse_DocumentClauseSetResponse>;
+}
+/**
+ * Output Representation for List of Clause Set
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentClauseSetListResponse {
+    documentClauseSets: Array<DocumentClauseSetResponse_DocumentClauseSetResponse>;
+}

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

@@ -0,0 +1,44 @@
+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 = "29a9e61a0952cff8f7e98cc7d8857c62";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DocumentClauseSetResponse, existing: DocumentClauseSetResponseNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DocumentClauseSetResponseNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DocumentClauseSetResponseNormalized, incoming: DocumentClauseSetResponseNormalized): boolean;
+export declare function deepFreeze(input: DocumentClauseSetResponse): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DocumentClauseSetResponse, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output Representation of Clause Set
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentClauseSetResponseNormalized {
+    /** Specifies the category of the Document Clause Set. */
+    category: string;
+    /** Specifies the Category Name of the Document Clause Set. */
+    categoryName: string;
+    /** Specifies the default language of the Document Clause Set. */
+    defaultLanguage: string;
+    /** Id of Document Clause Set */
+    id: string;
+    /** The name of the Document Clause Set. */
+    name: string;
+    /** Specifies the status of the Document Clause Set such as Draft, Active, or Archived. */
+    status: string;
+}
+/**
+ * Output Representation of Clause Set
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentClauseSetResponse {
+    category: string;
+    categoryName: string;
+    defaultLanguage: string;
+    id: string;
+    name: string;
+    status: string;
+}

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

@@ -0,0 +1,31 @@
+import { DocumentResponse as DocumentResponse_DocumentResponse } from './DocumentResponse';
+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 TTL = 60000;
+export declare const VERSION = "71edf629bc2d90d36d4a1ead41f16a6d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DocumentListResponse, existing: DocumentListResponseNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DocumentListResponseNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DocumentListResponseNormalized, incoming: DocumentListResponseNormalized): boolean;
+export declare function deepFreeze(input: DocumentListResponse): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DocumentListResponse, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Document record list
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentListResponseNormalized {
+    /** List of Documents associated to the sourceObjectId */
+    documents?: Array<DocumentResponse_DocumentResponse>;
+}
+/**
+ * Document record list
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentListResponse {
+    documents?: Array<DocumentResponse_DocumentResponse>;
+}

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

@@ -0,0 +1,45 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "0bb7df7b5d24fd4c03e5515621a5ad3c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: DocumentResponse, existing: DocumentResponseNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): DocumentResponseNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: DocumentResponseNormalized, incoming: DocumentResponseNormalized): boolean;
+export declare function deepFreeze(input: DocumentResponse): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: DocumentResponse, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Document record
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentResponseNormalized {
+    /** Additional fields related to document for custom implementation */
+    additionalFields?: {
+        [key: string]: string;
+    };
+    /** The fileExtension of Document */
+    fileExtension?: string;
+    /** The name of Document */
+    name?: string;
+    /** The sourceId of Document */
+    sourceId?: string;
+    /** The sourceType of Document */
+    sourceType?: string;
+}
+/**
+ * Document record
+ *
+ * Keys:
+ *    (none)
+ */
+export interface DocumentResponse {
+    additionalFields?: {
+        [key: string]: string;
+    };
+    fileExtension?: string;
+    name?: string;
+    sourceId?: string;
+    sourceType?: string;
+}

package/dist/types/src/generated/types/EnvelopeSendAnchorRequest.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 = "732903a5d9cc7578c8136c293bc14486";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EnvelopeSendAnchorRequest, existing: EnvelopeSendAnchorRequestNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EnvelopeSendAnchorRequestNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EnvelopeSendAnchorRequestNormalized, incoming: EnvelopeSendAnchorRequestNormalized): boolean;
+export declare function deepFreeze(input: EnvelopeSendAnchorRequest): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: EnvelopeSendAnchorRequest, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input Request representation to get send for esignature details from API
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendAnchorRequestNormalized {
+    /** Anchor String */
+    anchorString: string;
+    /** SignerRole */
+    signerRole: number;
+    /** tabType */
+    tabType: string;
+}
+/**
+ * Input Request representation to get send for esignature details from API
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendAnchorRequest {
+    anchorString: string;
+    signerRole: number;
+    tabType: string;
+}

package/dist/types/src/generated/types/EnvelopeSendAnchorsRequest.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 = "e2b8ecc613ff4804d25a0dc8f46c8c55";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EnvelopeSendAnchorsRequest, existing: EnvelopeSendAnchorsRequestNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EnvelopeSendAnchorsRequestNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EnvelopeSendAnchorsRequestNormalized, incoming: EnvelopeSendAnchorsRequestNormalized): boolean;
+export declare function deepFreeze(input: EnvelopeSendAnchorsRequest): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: EnvelopeSendAnchorsRequest, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input Request representation to get send for esignature details from API
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendAnchorsRequestNormalized {
+    /** Anchor List */
+    anchors: Array<{}>;
+}
+/**
+ * Input Request representation to get send for esignature details from API
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendAnchorsRequest {
+    anchors: Array<{}>;
+}

package/dist/types/src/generated/types/EnvelopeSendDocumentsRequest.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 = "15a07e4fdb55997c72d0f27a550f205c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EnvelopeSendDocumentsRequest, existing: EnvelopeSendDocumentsRequestNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EnvelopeSendDocumentsRequestNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EnvelopeSendDocumentsRequestNormalized, incoming: EnvelopeSendDocumentsRequestNormalized): boolean;
+export declare function deepFreeze(input: EnvelopeSendDocumentsRequest): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: EnvelopeSendDocumentsRequest, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation to get Document details for esign
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendDocumentsRequestNormalized {
+    /** documentId */
+    documentId: string;
+    /** fileExtension */
+    fileExtension: string;
+    /**  Name */
+    name: string;
+    /** sourceId */
+    sourceId: string;
+    /** sourceType */
+    sourceType: string;
+}
+/**
+ * Input representation to get Document details for esign
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendDocumentsRequest {
+    documentId: string;
+    fileExtension: string;
+    name: string;
+    sourceId: string;
+    sourceType: string;
+}

package/dist/types/src/generated/types/EnvelopeSendEmailNotificationRequest.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 = "d37a615193e06f3bf28b3a64ae3617ff";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EnvelopeSendEmailNotificationRequest, existing: EnvelopeSendEmailNotificationRequestNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EnvelopeSendEmailNotificationRequestNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EnvelopeSendEmailNotificationRequestNormalized, incoming: EnvelopeSendEmailNotificationRequestNormalized): boolean;
+export declare function deepFreeze(input: EnvelopeSendEmailNotificationRequest): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: EnvelopeSendEmailNotificationRequest, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation to get Email Notification Details
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendEmailNotificationRequestNormalized {
+    /** emailBody */
+    emailBody: string;
+    /** emailSubject */
+    emailSubject: string;
+    /** supportedLanguage */
+    supportedLanguage: string;
+}
+/**
+ * Input representation to get Email Notification Details
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendEmailNotificationRequest {
+    emailBody: string;
+    emailSubject: string;
+    supportedLanguage: string;
+}

package/dist/types/src/generated/types/EnvelopeSendEmailSettingsRequest.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 = "819b2a6181e48b0724db987eb4f55218";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EnvelopeSendEmailSettingsRequest, existing: EnvelopeSendEmailSettingsRequestNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EnvelopeSendEmailSettingsRequestNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EnvelopeSendEmailSettingsRequestNormalized, incoming: EnvelopeSendEmailSettingsRequestNormalized): boolean;
+export declare function deepFreeze(input: EnvelopeSendEmailSettingsRequest): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: EnvelopeSendEmailSettingsRequest, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * EmailSettings representation to get Email details from API
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendEmailSettingsRequestNormalized {
+    /** Email Body */
+    emailBody: string;
+    /** Email Subject */
+    emailSubject: string;
+}
+/**
+ * EmailSettings representation to get Email details from API
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendEmailSettingsRequest {
+    emailBody: string;
+    emailSubject: string;
+}

package/dist/types/src/generated/types/EnvelopeSendNotificationExpirationsRequest.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 = "dd1c325cd37a017e8e16508d459d8945";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EnvelopeSendNotificationExpirationsRequest, existing: EnvelopeSendNotificationExpirationsRequestNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EnvelopeSendNotificationExpirationsRequestNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EnvelopeSendNotificationExpirationsRequestNormalized, incoming: EnvelopeSendNotificationExpirationsRequestNormalized): boolean;
+export declare function deepFreeze(input: EnvelopeSendNotificationExpirationsRequest): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: EnvelopeSendNotificationExpirationsRequest, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation to get Notification Expiration info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendNotificationExpirationsRequestNormalized {
+    /** expireAfter */
+    expireAfter?: string;
+    /** expireEnabled */
+    expireEnabled?: string;
+    /** expireWarn */
+    expireWarn?: string;
+}
+/**
+ * Input representation to get Notification Expiration info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendNotificationExpirationsRequest {
+    expireAfter?: string;
+    expireEnabled?: string;
+    expireWarn?: string;
+}

package/dist/types/src/generated/types/EnvelopeSendNotificationRemindersRequest.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 = "03ba34c592ec21b0bfc394a8aabc3d0e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EnvelopeSendNotificationRemindersRequest, existing: EnvelopeSendNotificationRemindersRequestNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EnvelopeSendNotificationRemindersRequestNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EnvelopeSendNotificationRemindersRequestNormalized, incoming: EnvelopeSendNotificationRemindersRequestNormalized): boolean;
+export declare function deepFreeze(input: EnvelopeSendNotificationRemindersRequest): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: EnvelopeSendNotificationRemindersRequest, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation to get Notification Reminder info for esign document
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendNotificationRemindersRequestNormalized {
+    /** Reminder Delay */
+    reminderDelay?: string;
+    /** Reminder Enabled */
+    reminderEnabled?: string;
+    /** Reminder Frequency */
+    reminderFrequency?: string;
+}
+/**
+ * Input representation to get Notification Reminder info for esign document
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendNotificationRemindersRequest {
+    reminderDelay?: string;
+    reminderEnabled?: string;
+    reminderFrequency?: string;
+}

package/dist/types/src/generated/types/EnvelopeSendNotificationRequest.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 = "9612c6b107928b3412bac39099ffb92f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EnvelopeSendNotificationRequest, existing: EnvelopeSendNotificationRequestNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EnvelopeSendNotificationRequestNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EnvelopeSendNotificationRequestNormalized, incoming: EnvelopeSendNotificationRequestNormalized): boolean;
+export declare function deepFreeze(input: EnvelopeSendNotificationRequest): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: EnvelopeSendNotificationRequest, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation to get Notification Information for Esign
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendNotificationRequestNormalized {
+    /** expirations */
+    expirations?: {};
+    /** reminders */
+    reminders?: {};
+    /** useAccountDefaults */
+    useAccountDefaults?: boolean;
+}
+/**
+ * Input representation to get Notification Information for Esign
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendNotificationRequest {
+    expirations?: {};
+    reminders?: {};
+    useAccountDefaults?: boolean;
+}

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

@@ -0,0 +1,68 @@
+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 = "37d61b0e5143af40fd7dfd91c55c5ba1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EnvelopeSendRecipientDetailRequest, existing: EnvelopeSendRecipientDetailRequestNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EnvelopeSendRecipientDetailRequestNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EnvelopeSendRecipientDetailRequestNormalized, incoming: EnvelopeSendRecipientDetailRequestNormalized): boolean;
+export declare function deepFreeze(input: EnvelopeSendRecipientDetailRequest): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: EnvelopeSendRecipientDetailRequest, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation to get Recipient Details
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendRecipientDetailRequestNormalized {
+    /** Access Code */
+    accessCode?: string;
+    /** Email address of the Signer */
+    email: string;
+    /** Email Notifications */
+    emailNotification?: {};
+    /** Recipient Id */
+    id?: string;
+    /** Name */
+    name: string;
+    /** Parent Signer Name for Inperson Signers */
+    parentSignerName?: string;
+    /** Phone number of the Signer */
+    phone?: string;
+    /** Recipient Id */
+    recipientId?: string;
+    /** Recipient Locale */
+    recipientLocale?: string;
+    /** Recipient Type */
+    recipientType: string;
+    /** Routing Number */
+    routingNumber?: number;
+    /** Routing Order */
+    routingOrder?: number;
+    /** Signer Role */
+    signerRole?: number;
+    /** Title of the Signer */
+    title?: string;
+}
+/**
+ * Input representation to get Recipient Details
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EnvelopeSendRecipientDetailRequest {
+    accessCode?: string;
+    email: string;
+    emailNotification?: {};
+    id?: string;
+    name: string;
+    parentSignerName?: string;
+    phone?: string;
+    recipientId?: string;
+    recipientLocale?: string;
+    recipientType: string;
+    routingNumber?: number;
+    routingOrder?: number;
+    signerRole?: number;
+    title?: string;
+}