@cloudpdf/sdk 3.0.0-next.12 → 3.0.0-next.13

package/dist/esm/api/types/DocPagesSetName404Response.d.mts

@@ -29,6 +29,12 @@ export declare namespace DocPagesSetName404Response {
         readonly LayerVersionConflict: "LayerVersionConflict";
         readonly NotImplemented: "NotImplemented";
         readonly MalformedPdf: "MalformedPdf";
+        readonly SigningPending: "SigningPending";
+        readonly SigningExpired: "SigningExpired";
+        readonly SigningVersionMismatch: "SigningVersionMismatch";
+        readonly SignatureRefused: "SignatureRefused";
+        readonly ProtectedDocument: "ProtectedDocument";
+        readonly StaleBase: "StaleBase";
     };
     type Code = (typeof Code)[keyof typeof Code];
 }

package/dist/esm/api/types/DocPagesSetName404Response.mjs

@@ -24,5 +24,11 @@ export var DocPagesSetName404Response;
         LayerVersionConflict: "LayerVersionConflict",
         NotImplemented: "NotImplemented",
         MalformedPdf: "MalformedPdf",
+        SigningPending: "SigningPending",
+        SigningExpired: "SigningExpired",
+        SigningVersionMismatch: "SigningVersionMismatch",
+        SignatureRefused: "SignatureRefused",
+        ProtectedDocument: "ProtectedDocument",
+        StaleBase: "StaleBase",
     };
 })(DocPagesSetName404Response || (DocPagesSetName404Response = {}));

package/dist/esm/api/types/DocRedactionsApply200Response.d.mts

@@ -29,6 +29,8 @@ export declare namespace DocRedactionsApply200Response {
             previousDocVersion: number;
             docVersion: number;
             annotationsVersion?: number | undefined;
+            layerVersion?: number | undefined;
+            working?: boolean | undefined;
             pages: CacheDelta.Pages.Item[];
         }
         namespace CacheDelta {

package/dist/esm/api/types/DocRedactionsApply400Response.d.mts

@@ -29,6 +29,12 @@ export declare namespace DocRedactionsApply400Response {
         readonly LayerVersionConflict: "LayerVersionConflict";
         readonly NotImplemented: "NotImplemented";
         readonly MalformedPdf: "MalformedPdf";
+        readonly SigningPending: "SigningPending";
+        readonly SigningExpired: "SigningExpired";
+        readonly SigningVersionMismatch: "SigningVersionMismatch";
+        readonly SignatureRefused: "SignatureRefused";
+        readonly ProtectedDocument: "ProtectedDocument";
+        readonly StaleBase: "StaleBase";
     };
     type Code = (typeof Code)[keyof typeof Code];
 }

package/dist/esm/api/types/DocRedactionsApply400Response.mjs

@@ -24,5 +24,11 @@ export var DocRedactionsApply400Response;
         LayerVersionConflict: "LayerVersionConflict",
         NotImplemented: "NotImplemented",
         MalformedPdf: "MalformedPdf",
+        SigningPending: "SigningPending",
+        SigningExpired: "SigningExpired",
+        SigningVersionMismatch: "SigningVersionMismatch",
+        SignatureRefused: "SignatureRefused",
+        ProtectedDocument: "ProtectedDocument",
+        StaleBase: "StaleBase",
     };
 })(DocRedactionsApply400Response || (DocRedactionsApply400Response = {}));

package/dist/esm/api/types/DocRedactionsApply404Response.d.mts

@@ -29,6 +29,12 @@ export declare namespace DocRedactionsApply404Response {
         readonly LayerVersionConflict: "LayerVersionConflict";
         readonly NotImplemented: "NotImplemented";
         readonly MalformedPdf: "MalformedPdf";
+        readonly SigningPending: "SigningPending";
+        readonly SigningExpired: "SigningExpired";
+        readonly SigningVersionMismatch: "SigningVersionMismatch";
+        readonly SignatureRefused: "SignatureRefused";
+        readonly ProtectedDocument: "ProtectedDocument";
+        readonly StaleBase: "StaleBase";
     };
     type Code = (typeof Code)[keyof typeof Code];
 }

package/dist/esm/api/types/DocRedactionsApply404Response.mjs

@@ -24,5 +24,11 @@ export var DocRedactionsApply404Response;
         LayerVersionConflict: "LayerVersionConflict",
         NotImplemented: "NotImplemented",
         MalformedPdf: "MalformedPdf",
+        SigningPending: "SigningPending",
+        SigningExpired: "SigningExpired",
+        SigningVersionMismatch: "SigningVersionMismatch",
+        SignatureRefused: "SignatureRefused",
+        ProtectedDocument: "ProtectedDocument",
+        StaleBase: "StaleBase",
     };
 })(DocRedactionsApply404Response || (DocRedactionsApply404Response = {}));

package/dist/esm/api/types/DocRenderResponse.d.mts

@@ -29,6 +29,12 @@ export declare namespace DocRenderResponse {
         readonly LayerVersionConflict: "LayerVersionConflict";
         readonly NotImplemented: "NotImplemented";
         readonly MalformedPdf: "MalformedPdf";
+        readonly SigningPending: "SigningPending";
+        readonly SigningExpired: "SigningExpired";
+        readonly SigningVersionMismatch: "SigningVersionMismatch";
+        readonly SignatureRefused: "SignatureRefused";
+        readonly ProtectedDocument: "ProtectedDocument";
+        readonly StaleBase: "StaleBase";
     };
     type Code = (typeof Code)[keyof typeof Code];
 }

package/dist/esm/api/types/DocRenderResponse.mjs

@@ -24,5 +24,11 @@ export var DocRenderResponse;
         LayerVersionConflict: "LayerVersionConflict",
         NotImplemented: "NotImplemented",
         MalformedPdf: "MalformedPdf",
+        SigningPending: "SigningPending",
+        SigningExpired: "SigningExpired",
+        SigningVersionMismatch: "SigningVersionMismatch",
+        SignatureRefused: "SignatureRefused",
+        ProtectedDocument: "ProtectedDocument",
+        StaleBase: "StaleBase",
     };
 })(DocRenderResponse || (DocRenderResponse = {}));

package/dist/esm/api/types/DocSignaturesAbort200Response.d.mts

@@ -0,0 +1,11 @@
+export interface DocSignaturesAbort200Response {
+    status: DocSignaturesAbort200Response.Status;
+}
+export declare namespace DocSignaturesAbort200Response {
+    const Status: {
+        readonly Aborted: "aborted";
+        readonly AlreadyCompleted: "already-completed";
+        readonly Unknown: "unknown";
+    };
+    type Status = (typeof Status)[keyof typeof Status];
+}

package/dist/esm/api/types/DocSignaturesAbort200Response.mjs

@@ -0,0 +1,9 @@
+// This file was auto-generated by Fern from our API Definition.
+export var DocSignaturesAbort200Response;
+(function (DocSignaturesAbort200Response) {
+    DocSignaturesAbort200Response.Status = {
+        Aborted: "aborted",
+        AlreadyCompleted: "already-completed",
+        Unknown: "unknown",
+    };
+})(DocSignaturesAbort200Response || (DocSignaturesAbort200Response = {}));

package/dist/esm/api/types/DocSignaturesAbort404Response.d.mts

@@ -0,0 +1,40 @@
+export interface DocSignaturesAbort404Response {
+    name: DocSignaturesAbort404Response.Name;
+    code: DocSignaturesAbort404Response.Code;
+    message: string;
+    details?: Record<string, unknown> | undefined;
+}
+export declare namespace DocSignaturesAbort404Response {
+    const Name: {
+        readonly EngineError: "EngineError";
+    };
+    type Name = (typeof Name)[keyof typeof Name];
+    const Code: {
+        readonly Unknown: "Unknown";
+        readonly InvalidArg: "InvalidArg";
+        readonly DocNotOpen: "DocNotOpen";
+        readonly DocOpenFailed: "DocOpenFailed";
+        readonly DocPasswordRequired: "DocPasswordRequired";
+        readonly DocPasswordIncorrect: "DocPasswordIncorrect";
+        readonly SharePasswordRequired: "SharePasswordRequired";
+        readonly Aborted: "Aborted";
+        readonly Network: "Network";
+        readonly Unauthenticated: "Unauthenticated";
+        readonly Forbidden: "Forbidden";
+        readonly NotFound: "NotFound";
+        readonly WireFormat: "WireFormat";
+        readonly RuntimeUnavailable: "RuntimeUnavailable";
+        readonly InvalidReference: "InvalidReference";
+        readonly WeakAnnotationSessionConflict: "WeakAnnotationSessionConflict";
+        readonly LayerVersionConflict: "LayerVersionConflict";
+        readonly NotImplemented: "NotImplemented";
+        readonly MalformedPdf: "MalformedPdf";
+        readonly SigningPending: "SigningPending";
+        readonly SigningExpired: "SigningExpired";
+        readonly SigningVersionMismatch: "SigningVersionMismatch";
+        readonly SignatureRefused: "SignatureRefused";
+        readonly ProtectedDocument: "ProtectedDocument";
+        readonly StaleBase: "StaleBase";
+    };
+    type Code = (typeof Code)[keyof typeof Code];
+}

package/dist/esm/api/types/DocSignaturesAbort404Response.mjs

@@ -0,0 +1,34 @@
+// This file was auto-generated by Fern from our API Definition.
+export var DocSignaturesAbort404Response;
+(function (DocSignaturesAbort404Response) {
+    DocSignaturesAbort404Response.Name = {
+        EngineError: "EngineError",
+    };
+    DocSignaturesAbort404Response.Code = {
+        Unknown: "Unknown",
+        InvalidArg: "InvalidArg",
+        DocNotOpen: "DocNotOpen",
+        DocOpenFailed: "DocOpenFailed",
+        DocPasswordRequired: "DocPasswordRequired",
+        DocPasswordIncorrect: "DocPasswordIncorrect",
+        SharePasswordRequired: "SharePasswordRequired",
+        Aborted: "Aborted",
+        Network: "Network",
+        Unauthenticated: "Unauthenticated",
+        Forbidden: "Forbidden",
+        NotFound: "NotFound",
+        WireFormat: "WireFormat",
+        RuntimeUnavailable: "RuntimeUnavailable",
+        InvalidReference: "InvalidReference",
+        WeakAnnotationSessionConflict: "WeakAnnotationSessionConflict",
+        LayerVersionConflict: "LayerVersionConflict",
+        NotImplemented: "NotImplemented",
+        MalformedPdf: "MalformedPdf",
+        SigningPending: "SigningPending",
+        SigningExpired: "SigningExpired",
+        SigningVersionMismatch: "SigningVersionMismatch",
+        SignatureRefused: "SignatureRefused",
+        ProtectedDocument: "ProtectedDocument",
+        StaleBase: "StaleBase",
+    };
+})(DocSignaturesAbort404Response || (DocSignaturesAbort404Response = {}));

package/dist/esm/api/types/DocSignaturesAnalysis200Response.d.mts

@@ -0,0 +1,126 @@
+export interface DocSignaturesAnalysis200Response {
+    mode: DocSignaturesAnalysis200Response.Mode;
+    policyVersion: number;
+    basis: DocSignaturesAnalysis200Response.Basis;
+    since: DocSignaturesAnalysis200Response.Since;
+    until: DocSignaturesAnalysis200Response.Until;
+    restrictions: DocSignaturesAnalysis200Response.Restrictions.Item[];
+    current: DocSignaturesAnalysis200Response.Current;
+    later: DocSignaturesAnalysis200Response.Later;
+    verdict: DocSignaturesAnalysis200Response.Verdict;
+    steps: unknown[];
+}
+export declare namespace DocSignaturesAnalysis200Response {
+    const Mode: {
+        readonly Authoritative: "authoritative";
+        readonly Exploratory: "exploratory";
+    };
+    type Mode = (typeof Mode)[keyof typeof Mode];
+    interface Basis {
+        version: Basis.Version;
+        editsVersion: number;
+        source: Basis.Source;
+    }
+    namespace Basis {
+        interface Version {
+            sha256: string;
+            byteLength: number;
+        }
+        const Source: {
+            readonly Persisted: "persisted";
+            readonly WorkingCopy: "working-copy";
+        };
+        type Source = (typeof Source)[keyof typeof Source];
+    }
+    interface Since {
+        revisionIndex: number;
+        signatureIndex: number | null;
+    }
+    interface Until {
+        revisionIndex: number;
+    }
+    type Restrictions = Restrictions.Item[];
+    namespace Restrictions {
+        interface Item {
+            signatureIndex: number;
+            revisionIndex: number;
+            source: Item.Source;
+            own: boolean;
+            permission?: number | undefined;
+            fields?: unknown | undefined;
+        }
+        namespace Item {
+            const Source: {
+                readonly Docmdp: "docmdp";
+                readonly Fieldmdp: "fieldmdp";
+                readonly Lock: "lock";
+            };
+            type Source = (typeof Source)[keyof typeof Source];
+        }
+    }
+    interface Current {
+        verdict: Current.Verdict;
+        complete: boolean;
+        primary?: Current.Primary | undefined;
+        findings: Current.Findings.Item[];
+        method: Current.Method;
+    }
+    namespace Current {
+        const Verdict: {
+            readonly Unchanged: "unchanged";
+            readonly Permitted: "permitted";
+            readonly Forbidden: "forbidden";
+            readonly Indeterminate: "indeterminate";
+        };
+        type Verdict = (typeof Verdict)[keyof typeof Verdict];
+        interface Primary {
+            rule: string;
+            verdict: Primary.Verdict;
+            objectNumber: number;
+            edge?: string | undefined;
+            detail?: string | undefined;
+        }
+        namespace Primary {
+            const Verdict: {
+                readonly Permitted: "permitted";
+                readonly Forbidden: "forbidden";
+                readonly Incomplete: "incomplete";
+            };
+            type Verdict = (typeof Verdict)[keyof typeof Verdict];
+        }
+        type Findings = Findings.Item[];
+        namespace Findings {
+            interface Item {
+                rule: string;
+                verdict: Item.Verdict;
+                objectNumber: number;
+                edge?: string | undefined;
+                detail?: string | undefined;
+            }
+            namespace Item {
+                const Verdict: {
+                    readonly Permitted: "permitted";
+                    readonly Forbidden: "forbidden";
+                    readonly Incomplete: "incomplete";
+                };
+                type Verdict = (typeof Verdict)[keyof typeof Verdict];
+            }
+        }
+        const Method: {
+            readonly NetState: "net-state";
+            readonly NetStateReplay: "net-state+replay";
+        };
+        type Method = (typeof Method)[keyof typeof Method];
+    }
+    interface Later {
+        revisionCount: number;
+        undoneObjectNumbers: number[];
+    }
+    const Verdict: {
+        readonly Unchanged: "unchanged";
+        readonly Permitted: "permitted";
+        readonly Forbidden: "forbidden";
+        readonly Indeterminate: "indeterminate";
+    };
+    type Verdict = (typeof Verdict)[keyof typeof Verdict];
+}

package/dist/esm/api/types/DocSignaturesAnalysis200Response.mjs

@@ -0,0 +1,64 @@
+// This file was auto-generated by Fern from our API Definition.
+export var DocSignaturesAnalysis200Response;
+(function (DocSignaturesAnalysis200Response) {
+    DocSignaturesAnalysis200Response.Mode = {
+        Authoritative: "authoritative",
+        Exploratory: "exploratory",
+    };
+    let Basis;
+    (function (Basis) {
+        Basis.Source = {
+            Persisted: "persisted",
+            WorkingCopy: "working-copy",
+        };
+    })(Basis = DocSignaturesAnalysis200Response.Basis || (DocSignaturesAnalysis200Response.Basis = {}));
+    let Restrictions;
+    (function (Restrictions) {
+        let Item;
+        (function (Item) {
+            Item.Source = {
+                Docmdp: "docmdp",
+                Fieldmdp: "fieldmdp",
+                Lock: "lock",
+            };
+        })(Item = Restrictions.Item || (Restrictions.Item = {}));
+    })(Restrictions = DocSignaturesAnalysis200Response.Restrictions || (DocSignaturesAnalysis200Response.Restrictions = {}));
+    let Current;
+    (function (Current) {
+        Current.Verdict = {
+            Unchanged: "unchanged",
+            Permitted: "permitted",
+            Forbidden: "forbidden",
+            Indeterminate: "indeterminate",
+        };
+        let Primary;
+        (function (Primary) {
+            Primary.Verdict = {
+                Permitted: "permitted",
+                Forbidden: "forbidden",
+                Incomplete: "incomplete",
+            };
+        })(Primary = Current.Primary || (Current.Primary = {}));
+        let Findings;
+        (function (Findings) {
+            let Item;
+            (function (Item) {
+                Item.Verdict = {
+                    Permitted: "permitted",
+                    Forbidden: "forbidden",
+                    Incomplete: "incomplete",
+                };
+            })(Item = Findings.Item || (Findings.Item = {}));
+        })(Findings = Current.Findings || (Current.Findings = {}));
+        Current.Method = {
+            NetState: "net-state",
+            NetStateReplay: "net-state+replay",
+        };
+    })(Current = DocSignaturesAnalysis200Response.Current || (DocSignaturesAnalysis200Response.Current = {}));
+    DocSignaturesAnalysis200Response.Verdict = {
+        Unchanged: "unchanged",
+        Permitted: "permitted",
+        Forbidden: "forbidden",
+        Indeterminate: "indeterminate",
+    };
+})(DocSignaturesAnalysis200Response || (DocSignaturesAnalysis200Response = {}));

package/dist/esm/api/types/DocSignaturesAnalysis400Response.d.mts

@@ -0,0 +1,40 @@
+export interface DocSignaturesAnalysis400Response {
+    name: DocSignaturesAnalysis400Response.Name;
+    code: DocSignaturesAnalysis400Response.Code;
+    message: string;
+    details?: Record<string, unknown> | undefined;
+}
+export declare namespace DocSignaturesAnalysis400Response {
+    const Name: {
+        readonly EngineError: "EngineError";
+    };
+    type Name = (typeof Name)[keyof typeof Name];
+    const Code: {
+        readonly Unknown: "Unknown";
+        readonly InvalidArg: "InvalidArg";
+        readonly DocNotOpen: "DocNotOpen";
+        readonly DocOpenFailed: "DocOpenFailed";
+        readonly DocPasswordRequired: "DocPasswordRequired";
+        readonly DocPasswordIncorrect: "DocPasswordIncorrect";
+        readonly SharePasswordRequired: "SharePasswordRequired";
+        readonly Aborted: "Aborted";
+        readonly Network: "Network";
+        readonly Unauthenticated: "Unauthenticated";
+        readonly Forbidden: "Forbidden";
+        readonly NotFound: "NotFound";
+        readonly WireFormat: "WireFormat";
+        readonly RuntimeUnavailable: "RuntimeUnavailable";
+        readonly InvalidReference: "InvalidReference";
+        readonly WeakAnnotationSessionConflict: "WeakAnnotationSessionConflict";
+        readonly LayerVersionConflict: "LayerVersionConflict";
+        readonly NotImplemented: "NotImplemented";
+        readonly MalformedPdf: "MalformedPdf";
+        readonly SigningPending: "SigningPending";
+        readonly SigningExpired: "SigningExpired";
+        readonly SigningVersionMismatch: "SigningVersionMismatch";
+        readonly SignatureRefused: "SignatureRefused";
+        readonly ProtectedDocument: "ProtectedDocument";
+        readonly StaleBase: "StaleBase";
+    };
+    type Code = (typeof Code)[keyof typeof Code];
+}

package/dist/esm/api/types/DocSignaturesAnalysis400Response.mjs

@@ -0,0 +1,34 @@
+// This file was auto-generated by Fern from our API Definition.
+export var DocSignaturesAnalysis400Response;
+(function (DocSignaturesAnalysis400Response) {
+    DocSignaturesAnalysis400Response.Name = {
+        EngineError: "EngineError",
+    };
+    DocSignaturesAnalysis400Response.Code = {
+        Unknown: "Unknown",
+        InvalidArg: "InvalidArg",
+        DocNotOpen: "DocNotOpen",
+        DocOpenFailed: "DocOpenFailed",
+        DocPasswordRequired: "DocPasswordRequired",
+        DocPasswordIncorrect: "DocPasswordIncorrect",
+        SharePasswordRequired: "SharePasswordRequired",
+        Aborted: "Aborted",
+        Network: "Network",
+        Unauthenticated: "Unauthenticated",
+        Forbidden: "Forbidden",
+        NotFound: "NotFound",
+        WireFormat: "WireFormat",
+        RuntimeUnavailable: "RuntimeUnavailable",
+        InvalidReference: "InvalidReference",
+        WeakAnnotationSessionConflict: "WeakAnnotationSessionConflict",
+        LayerVersionConflict: "LayerVersionConflict",
+        NotImplemented: "NotImplemented",
+        MalformedPdf: "MalformedPdf",
+        SigningPending: "SigningPending",
+        SigningExpired: "SigningExpired",
+        SigningVersionMismatch: "SigningVersionMismatch",
+        SignatureRefused: "SignatureRefused",
+        ProtectedDocument: "ProtectedDocument",
+        StaleBase: "StaleBase",
+    };
+})(DocSignaturesAnalysis400Response || (DocSignaturesAnalysis400Response = {}));

package/dist/esm/api/types/DocSignaturesAnalysis404Response.d.mts

@@ -0,0 +1,40 @@
+export interface DocSignaturesAnalysis404Response {
+    name: DocSignaturesAnalysis404Response.Name;
+    code: DocSignaturesAnalysis404Response.Code;
+    message: string;
+    details?: Record<string, unknown> | undefined;
+}
+export declare namespace DocSignaturesAnalysis404Response {
+    const Name: {
+        readonly EngineError: "EngineError";
+    };
+    type Name = (typeof Name)[keyof typeof Name];
+    const Code: {
+        readonly Unknown: "Unknown";
+        readonly InvalidArg: "InvalidArg";
+        readonly DocNotOpen: "DocNotOpen";
+        readonly DocOpenFailed: "DocOpenFailed";
+        readonly DocPasswordRequired: "DocPasswordRequired";
+        readonly DocPasswordIncorrect: "DocPasswordIncorrect";
+        readonly SharePasswordRequired: "SharePasswordRequired";
+        readonly Aborted: "Aborted";
+        readonly Network: "Network";
+        readonly Unauthenticated: "Unauthenticated";
+        readonly Forbidden: "Forbidden";
+        readonly NotFound: "NotFound";
+        readonly WireFormat: "WireFormat";
+        readonly RuntimeUnavailable: "RuntimeUnavailable";
+        readonly InvalidReference: "InvalidReference";
+        readonly WeakAnnotationSessionConflict: "WeakAnnotationSessionConflict";
+        readonly LayerVersionConflict: "LayerVersionConflict";
+        readonly NotImplemented: "NotImplemented";
+        readonly MalformedPdf: "MalformedPdf";
+        readonly SigningPending: "SigningPending";
+        readonly SigningExpired: "SigningExpired";
+        readonly SigningVersionMismatch: "SigningVersionMismatch";
+        readonly SignatureRefused: "SignatureRefused";
+        readonly ProtectedDocument: "ProtectedDocument";
+        readonly StaleBase: "StaleBase";
+    };
+    type Code = (typeof Code)[keyof typeof Code];
+}

package/dist/esm/api/types/DocSignaturesAnalysis404Response.mjs

@@ -0,0 +1,34 @@
+// This file was auto-generated by Fern from our API Definition.
+export var DocSignaturesAnalysis404Response;
+(function (DocSignaturesAnalysis404Response) {
+    DocSignaturesAnalysis404Response.Name = {
+        EngineError: "EngineError",
+    };
+    DocSignaturesAnalysis404Response.Code = {
+        Unknown: "Unknown",
+        InvalidArg: "InvalidArg",
+        DocNotOpen: "DocNotOpen",
+        DocOpenFailed: "DocOpenFailed",
+        DocPasswordRequired: "DocPasswordRequired",
+        DocPasswordIncorrect: "DocPasswordIncorrect",
+        SharePasswordRequired: "SharePasswordRequired",
+        Aborted: "Aborted",
+        Network: "Network",
+        Unauthenticated: "Unauthenticated",
+        Forbidden: "Forbidden",
+        NotFound: "NotFound",
+        WireFormat: "WireFormat",
+        RuntimeUnavailable: "RuntimeUnavailable",
+        InvalidReference: "InvalidReference",
+        WeakAnnotationSessionConflict: "WeakAnnotationSessionConflict",
+        LayerVersionConflict: "LayerVersionConflict",
+        NotImplemented: "NotImplemented",
+        MalformedPdf: "MalformedPdf",
+        SigningPending: "SigningPending",
+        SigningExpired: "SigningExpired",
+        SigningVersionMismatch: "SigningVersionMismatch",
+        SignatureRefused: "SignatureRefused",
+        ProtectedDocument: "ProtectedDocument",
+        StaleBase: "StaleBase",
+    };
+})(DocSignaturesAnalysis404Response || (DocSignaturesAnalysis404Response = {}));