docspring-ts 1.0.2 → 2.0.0

package/dist/models/UploadPresignResponse.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadPresignResponseMethodEnum = exports.UploadPresignResponse = void 0;
+var UploadPresignResponse = (function () {
+    function UploadPresignResponse() {
+    }
+    UploadPresignResponse.getAttributeTypeMap = function () {
+        return UploadPresignResponse.attributeTypeMap;
+    };
+    UploadPresignResponse.discriminator = undefined;
+    UploadPresignResponse.mapping = undefined;
+    UploadPresignResponse.attributeTypeMap = [
+        {
+            "name": "fields",
+            "baseName": "fields",
+            "type": "any",
+            "format": ""
+        },
+        {
+            "name": "headers",
+            "baseName": "headers",
+            "type": "any",
+            "format": ""
+        },
+        {
+            "name": "url",
+            "baseName": "url",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "method",
+            "baseName": "method",
+            "type": "UploadPresignResponseMethodEnum",
+            "format": ""
+        }
+    ];
+    return UploadPresignResponse;
+}());
+exports.UploadPresignResponse = UploadPresignResponse;
+var UploadPresignResponseMethodEnum;
+(function (UploadPresignResponseMethodEnum) {
+    UploadPresignResponseMethodEnum["Post"] = "post";
+})(UploadPresignResponseMethodEnum = exports.UploadPresignResponseMethodEnum || (exports.UploadPresignResponseMethodEnum = {}));
+//# sourceMappingURL=UploadPresignResponse.js.map

package/dist/models/UploadPresignResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UploadPresignResponse.js","sourceRoot":"","sources":["../../models/UploadPresignResponse.ts"],"names":[],"mappings":";;;AAcA;IAwCI;IACA,CAAC;IALM,yCAAmB,GAA1B;QACI,OAAO,qBAAqB,CAAC,gBAAgB,CAAC;IAClD,CAAC;IAhCe,mCAAa,GAAuB,SAAS,CAAC;IAE9C,6BAAO,GAA0C,SAAS,CAAC;IAE3D,sCAAgB,GAA0E;QACtG;YACI,MAAM,EAAE,QAAQ;YAChB,UAAU,EAAE,QAAQ;YACpB,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,EAAE;SACf;QACD;YACI,MAAM,EAAE,SAAS;YACjB,UAAU,EAAE,SAAS;YACrB,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,EAAE;SACf;QACD;YACI,MAAM,EAAE,KAAK;YACb,UAAU,EAAE,KAAK;YACjB,MAAM,EAAE,QAAQ;YAChB,QAAQ,EAAE,EAAE;SACf;QACD;YACI,MAAM,EAAE,QAAQ;YAChB,UAAU,EAAE,QAAQ;YACpB,MAAM,EAAE,iCAAiC;YACzC,QAAQ,EAAE,EAAE;SACf;KAAK,CAAC;IAQf,4BAAC;CAAA,AA1CD,IA0CC;AA1CY,sDAAqB;AA4ClC,IAAY,+BAEX;AAFD,WAAY,+BAA+B;IACvC,gDAAa,CAAA;AACjB,CAAC,EAFW,+BAA+B,GAA/B,uCAA+B,KAA/B,uCAA+B,QAE1C"}

package/dist/models/all.d.ts

@@ -0,0 +1,48 @@
+export * from '../models/AddFieldsData';
+export * from '../models/BatchGeneratePdfs201Response';
+export * from '../models/CombinePdfsData';
+export * from '../models/CombinedSubmission';
+export * from '../models/CombinedSubmissionAction';
+export * from '../models/CombinedSubmissionData';
+export * from '../models/CopyTemplateOptions';
+export * from '../models/CreateCombinedSubmissionResponse';
+export * from '../models/CreateCustomFileData';
+export * from '../models/CreateCustomFileResponse';
+export * from '../models/CreateFolderData';
+export * from '../models/CreateHtmlSubmissionData';
+export * from '../models/CreateHtmlTemplate';
+export * from '../models/CreatePdfSubmissionData';
+export * from '../models/CreatePdfTemplate';
+export * from '../models/CreateSubmissionDataRequestData';
+export * from '../models/CreateSubmissionDataRequestEventRequest';
+export * from '../models/CreateSubmissionDataRequestEventResponse';
+export * from '../models/CreateSubmissionDataRequestResponse';
+export * from '../models/CreateSubmissionDataRequestTokenResponse';
+export * from '../models/CreateSubmissionResponse';
+export * from '../models/CustomFile';
+export * from '../models/ErrorResponse';
+export * from '../models/Folder';
+export * from '../models/JsonSchema';
+export * from '../models/ListSubmissionsResponse';
+export * from '../models/MoveFolderData';
+export * from '../models/MoveTemplateData';
+export * from '../models/MultipleErrorsResponse';
+export * from '../models/RenameFolderData';
+export * from '../models/Submission';
+export * from '../models/SubmissionAction';
+export * from '../models/SubmissionBatch';
+export * from '../models/SubmissionBatchData';
+export * from '../models/SubmissionBatchWithSubmissions';
+export * from '../models/SubmissionDataRequest';
+export * from '../models/SubmissionDataRequestEvent';
+export * from '../models/SubmissionDataRequestShow';
+export * from '../models/SubmissionDataRequestToken';
+export * from '../models/SubmissionPreview';
+export * from '../models/SuccessErrorResponse';
+export * from '../models/SuccessMultipleErrorsResponse';
+export * from '../models/Template';
+export * from '../models/TemplateAddFieldsResponse';
+export * from '../models/TemplatePreview';
+export * from '../models/UpdateHtmlTemplate';
+export * from '../models/UpdateSubmissionDataRequestData';
+export * from '../models/UploadPresignResponse';

package/dist/models/all.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../models/AddFieldsData"), exports);
+__exportStar(require("../models/BatchGeneratePdfs201Response"), exports);
+__exportStar(require("../models/CombinePdfsData"), exports);
+__exportStar(require("../models/CombinedSubmission"), exports);
+__exportStar(require("../models/CombinedSubmissionAction"), exports);
+__exportStar(require("../models/CombinedSubmissionData"), exports);
+__exportStar(require("../models/CopyTemplateOptions"), exports);
+__exportStar(require("../models/CreateCombinedSubmissionResponse"), exports);
+__exportStar(require("../models/CreateCustomFileData"), exports);
+__exportStar(require("../models/CreateCustomFileResponse"), exports);
+__exportStar(require("../models/CreateFolderData"), exports);
+__exportStar(require("../models/CreateHtmlSubmissionData"), exports);
+__exportStar(require("../models/CreateHtmlTemplate"), exports);
+__exportStar(require("../models/CreatePdfSubmissionData"), exports);
+__exportStar(require("../models/CreatePdfTemplate"), exports);
+__exportStar(require("../models/CreateSubmissionDataRequestData"), exports);
+__exportStar(require("../models/CreateSubmissionDataRequestEventRequest"), exports);
+__exportStar(require("../models/CreateSubmissionDataRequestEventResponse"), exports);
+__exportStar(require("../models/CreateSubmissionDataRequestResponse"), exports);
+__exportStar(require("../models/CreateSubmissionDataRequestTokenResponse"), exports);
+__exportStar(require("../models/CreateSubmissionResponse"), exports);
+__exportStar(require("../models/CustomFile"), exports);
+__exportStar(require("../models/ErrorResponse"), exports);
+__exportStar(require("../models/Folder"), exports);
+__exportStar(require("../models/JsonSchema"), exports);
+__exportStar(require("../models/ListSubmissionsResponse"), exports);
+__exportStar(require("../models/MoveFolderData"), exports);
+__exportStar(require("../models/MoveTemplateData"), exports);
+__exportStar(require("../models/MultipleErrorsResponse"), exports);
+__exportStar(require("../models/RenameFolderData"), exports);
+__exportStar(require("../models/Submission"), exports);
+__exportStar(require("../models/SubmissionAction"), exports);
+__exportStar(require("../models/SubmissionBatch"), exports);
+__exportStar(require("../models/SubmissionBatchData"), exports);
+__exportStar(require("../models/SubmissionBatchWithSubmissions"), exports);
+__exportStar(require("../models/SubmissionDataRequest"), exports);
+__exportStar(require("../models/SubmissionDataRequestEvent"), exports);
+__exportStar(require("../models/SubmissionDataRequestShow"), exports);
+__exportStar(require("../models/SubmissionDataRequestToken"), exports);
+__exportStar(require("../models/SubmissionPreview"), exports);
+__exportStar(require("../models/SuccessErrorResponse"), exports);
+__exportStar(require("../models/SuccessMultipleErrorsResponse"), exports);
+__exportStar(require("../models/Template"), exports);
+__exportStar(require("../models/TemplateAddFieldsResponse"), exports);
+__exportStar(require("../models/TemplatePreview"), exports);
+__exportStar(require("../models/UpdateHtmlTemplate"), exports);
+__exportStar(require("../models/UpdateSubmissionDataRequestData"), exports);
+__exportStar(require("../models/UploadPresignResponse"), exports);
+//# sourceMappingURL=all.js.map

package/dist/models/all.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"all.js","sourceRoot":"","sources":["../../models/all.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0DAAuC;AACvC,yEAAsD;AACtD,4DAAyC;AACzC,+DAA4C;AAC5C,qEAAkD;AAClD,mEAAgD;AAChD,gEAA6C;AAC7C,6EAA0D;AAC1D,iEAA8C;AAC9C,qEAAkD;AAClD,6DAA0C;AAC1C,qEAAkD;AAClD,+DAA4C;AAC5C,oEAAiD;AACjD,8DAA2C;AAC3C,4EAAyD;AACzD,oFAAiE;AACjE,qFAAkE;AAClE,gFAA6D;AAC7D,qFAAkE;AAClE,qEAAkD;AAClD,uDAAoC;AACpC,0DAAuC;AACvC,mDAAgC;AAChC,uDAAoC;AACpC,oEAAiD;AACjD,2DAAwC;AACxC,6DAA0C;AAC1C,mEAAgD;AAChD,6DAA0C;AAC1C,uDAAoC;AACpC,6DAA0C;AAC1C,4DAAyC;AACzC,gEAA6C;AAC7C,2EAAwD;AACxD,kEAA+C;AAC/C,uEAAoD;AACpD,sEAAmD;AACnD,uEAAoD;AACpD,8DAA2C;AAC3C,iEAA8C;AAC9C,0EAAuD;AACvD,qDAAkC;AAClC,sEAAmD;AACnD,4DAAyC;AACzC,+DAA4C;AAC5C,4EAAyD;AACzD,kEAA+C"}

package/dist/rxjsStub.d.ts

@@ -0,0 +1,10 @@
+export declare class Observable<T> {
+    private promise;
+    constructor(promise: Promise<T>);
+    toPromise(): Promise<T>;
+    pipe<S>(callback: (value: T) => S | Promise<S>): Observable<S>;
+}
+export declare function from<T>(promise: Promise<any>): Observable<any>;
+export declare function of<T>(value: T): Observable<T>;
+export declare function mergeMap<T, S>(callback: (value: T) => Observable<S>): (value: T) => Promise<S>;
+export declare function map(callback: any): any;

package/dist/rxjsStub.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.map = exports.mergeMap = exports.of = exports.from = exports.Observable = void 0;
+var Observable = (function () {
+    function Observable(promise) {
+        this.promise = promise;
+    }
+    Observable.prototype.toPromise = function () {
+        return this.promise;
+    };
+    Observable.prototype.pipe = function (callback) {
+        return new Observable(this.promise.then(callback));
+    };
+    return Observable;
+}());
+exports.Observable = Observable;
+function from(promise) {
+    return new Observable(promise);
+}
+exports.from = from;
+function of(value) {
+    return new Observable(Promise.resolve(value));
+}
+exports.of = of;
+function mergeMap(callback) {
+    return function (value) { return callback(value).toPromise(); };
+}
+exports.mergeMap = mergeMap;
+function map(callback) {
+    return callback;
+}
+exports.map = map;
+//# sourceMappingURL=rxjsStub.js.map

package/dist/rxjsStub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rxjsStub.js","sourceRoot":"","sources":["../rxjsStub.ts"],"names":[],"mappings":";;;AAAA;IACE,oBAAoB,OAAmB;QAAnB,YAAO,GAAP,OAAO,CAAY;IAAG,CAAC;IAE3C,8BAAS,GAAT;QACE,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,yBAAI,GAAJ,UAAQ,QAAsC;QAC5C,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;IACrD,CAAC;IACH,iBAAC;AAAD,CAAC,AAVD,IAUC;AAVY,gCAAU;AAYvB,SAAgB,IAAI,CAAI,OAAqB;IAC3C,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC,CAAC;AACjC,CAAC;AAFD,oBAEC;AAED,SAAgB,EAAE,CAAI,KAAQ;IAC5B,OAAO,IAAI,UAAU,CAAI,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AACnD,CAAC;AAFD,gBAEC;AAED,SAAgB,QAAQ,CAAO,QAAqC;IAClE,OAAO,UAAC,KAAQ,IAAK,OAAA,QAAQ,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,EAA3B,CAA2B,CAAC;AACnD,CAAC;AAFD,4BAEC;AAED,SAAgB,GAAG,CAAC,QAAa;IAC/B,OAAO,QAAQ,CAAC;AAClB,CAAC;AAFD,kBAEC"}

package/dist/servers.d.ts

@@ -0,0 +1,17 @@
+import { RequestContext, HttpMethod } from "./http/http";
+export interface BaseServerConfiguration {
+    makeRequestContext(endpoint: string, httpMethod: HttpMethod): RequestContext;
+}
+export declare class ServerConfiguration<T extends {
+    [key: string]: string;
+}> implements BaseServerConfiguration {
+    private url;
+    private variableConfiguration;
+    constructor(url: string, variableConfiguration: T);
+    setVariables(variableConfiguration: Partial<T>): void;
+    getConfiguration(): T;
+    private getUrl;
+    makeRequestContext(endpoint: string, httpMethod: HttpMethod): RequestContext;
+}
+export declare const server1: ServerConfiguration<{}>;
+export declare const servers: ServerConfiguration<{}>[];

package/dist/servers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.servers = exports.server1 = exports.ServerConfiguration = void 0;
+var http_1 = require("./http/http");
+var ServerConfiguration = (function () {
+    function ServerConfiguration(url, variableConfiguration) {
+        this.url = url;
+        this.variableConfiguration = variableConfiguration;
+    }
+    ServerConfiguration.prototype.setVariables = function (variableConfiguration) {
+        Object.assign(this.variableConfiguration, variableConfiguration);
+    };
+    ServerConfiguration.prototype.getConfiguration = function () {
+        return this.variableConfiguration;
+    };
+    ServerConfiguration.prototype.getUrl = function () {
+        var replacedUrl = this.url;
+        for (var _i = 0, _a = Object.entries(this.variableConfiguration); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], value = _b[1];
+            replacedUrl = replacedUrl.replaceAll("{".concat(key, "}"), value);
+        }
+        return replacedUrl;
+    };
+    ServerConfiguration.prototype.makeRequestContext = function (endpoint, httpMethod) {
+        return new http_1.RequestContext(this.getUrl() + endpoint, httpMethod);
+    };
+    return ServerConfiguration;
+}());
+exports.ServerConfiguration = ServerConfiguration;
+exports.server1 = new ServerConfiguration("https://sync.api.docspring.com/api/v1", {});
+exports.servers = [exports.server1];
+//# sourceMappingURL=servers.js.map

package/dist/servers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"servers.js","sourceRoot":"","sources":["../servers.ts"],"names":[],"mappings":";;;AAAA,oCAAyD;AAYzD;IACI,6BAA2B,GAAW,EAAU,qBAAwB;QAA7C,QAAG,GAAH,GAAG,CAAQ;QAAU,0BAAqB,GAArB,qBAAqB,CAAG;IAAG,CAAC;IASrE,0CAAY,GAAnB,UAAoB,qBAAiC;QACjD,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE,qBAAqB,CAAC,CAAC;IACrE,CAAC;IAEM,8CAAgB,GAAvB;QACI,OAAO,IAAI,CAAC,qBAAqB,CAAA;IACrC,CAAC;IAEO,oCAAM,GAAd;QACI,IAAI,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC;QAC3B,KAA2B,UAA0C,EAA1C,KAAA,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,qBAAqB,CAAC,EAA1C,cAA0C,EAA1C,IAA0C,EAAE;YAA5D,IAAA,WAAY,EAAX,GAAG,QAAA,EAAE,KAAK,QAAA;YAClB,WAAW,GAAG,WAAW,CAAC,UAAU,CAAC,WAAI,GAAG,MAAG,EAAE,KAAK,CAAC,CAAC;SAC3D;QACD,OAAO,WAAW,CAAA;IACtB,CAAC;IAUM,gDAAkB,GAAzB,UAA0B,QAAgB,EAAE,UAAsB;QAC9D,OAAO,IAAI,qBAAc,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,QAAQ,EAAE,UAAU,CAAC,CAAC;IACpE,CAAC;IACL,0BAAC;AAAD,CAAC,AArCD,IAqCC;AArCY,kDAAmB;AAuCnB,QAAA,OAAO,GAAG,IAAI,mBAAmB,CAAO,uCAAuC,EAAE,EAAI,CAAC,CAAA;AAEtF,QAAA,OAAO,GAAG,CAAC,eAAO,CAAC,CAAC"}

package/dist/types/ObjectParamAPI.d.ts

@@ -0,0 +1,269 @@
+import { HttpFile, HttpInfo } from '../http/http';
+import { Configuration } from '../configuration';
+import { AddFieldsData } from '../models/AddFieldsData';
+import { BatchGeneratePdfs201Response } from '../models/BatchGeneratePdfs201Response';
+import { CombinePdfsData } from '../models/CombinePdfsData';
+import { CombinedSubmission } from '../models/CombinedSubmission';
+import { CombinedSubmissionData } from '../models/CombinedSubmissionData';
+import { CopyTemplateOptions } from '../models/CopyTemplateOptions';
+import { CreateCombinedSubmissionResponse } from '../models/CreateCombinedSubmissionResponse';
+import { CreateCustomFileData } from '../models/CreateCustomFileData';
+import { CreateCustomFileResponse } from '../models/CreateCustomFileResponse';
+import { CreateFolderData } from '../models/CreateFolderData';
+import { CreateHtmlSubmissionData } from '../models/CreateHtmlSubmissionData';
+import { CreateHtmlTemplate } from '../models/CreateHtmlTemplate';
+import { CreatePdfSubmissionData } from '../models/CreatePdfSubmissionData';
+import { CreatePdfTemplate } from '../models/CreatePdfTemplate';
+import { CreateSubmissionDataRequestEventRequest } from '../models/CreateSubmissionDataRequestEventRequest';
+import { CreateSubmissionDataRequestEventResponse } from '../models/CreateSubmissionDataRequestEventResponse';
+import { CreateSubmissionDataRequestResponse } from '../models/CreateSubmissionDataRequestResponse';
+import { CreateSubmissionDataRequestTokenResponse } from '../models/CreateSubmissionDataRequestTokenResponse';
+import { CreateSubmissionResponse } from '../models/CreateSubmissionResponse';
+import { Folder } from '../models/Folder';
+import { JsonSchema } from '../models/JsonSchema';
+import { ListSubmissionsResponse } from '../models/ListSubmissionsResponse';
+import { MoveFolderData } from '../models/MoveFolderData';
+import { MoveTemplateData } from '../models/MoveTemplateData';
+import { RenameFolderData } from '../models/RenameFolderData';
+import { Submission } from '../models/Submission';
+import { SubmissionBatchData } from '../models/SubmissionBatchData';
+import { SubmissionBatchWithSubmissions } from '../models/SubmissionBatchWithSubmissions';
+import { SubmissionDataRequestShow } from '../models/SubmissionDataRequestShow';
+import { SubmissionPreview } from '../models/SubmissionPreview';
+import { SuccessErrorResponse } from '../models/SuccessErrorResponse';
+import { SuccessMultipleErrorsResponse } from '../models/SuccessMultipleErrorsResponse';
+import { Template } from '../models/Template';
+import { TemplateAddFieldsResponse } from '../models/TemplateAddFieldsResponse';
+import { TemplatePreview } from '../models/TemplatePreview';
+import { UpdateHtmlTemplate } from '../models/UpdateHtmlTemplate';
+import { UpdateSubmissionDataRequestData } from '../models/UpdateSubmissionDataRequestData';
+import { UploadPresignResponse } from '../models/UploadPresignResponse';
+import { PDFApiRequestFactory, PDFApiResponseProcessor } from "../apis/PDFApi";
+export interface PDFApiAddFieldsToTemplateRequest {
+    templateId: string;
+    data: AddFieldsData;
+}
+export interface PDFApiBatchGeneratePdfsRequest {
+    data: SubmissionBatchData;
+    wait?: boolean;
+}
+export interface PDFApiCombinePdfsRequest {
+    data: CombinePdfsData;
+}
+export interface PDFApiCombineSubmissionsRequest {
+    data: CombinedSubmissionData;
+    wait?: boolean;
+}
+export interface PDFApiCopyTemplateRequest {
+    templateId: string;
+    options?: CopyTemplateOptions;
+}
+export interface PDFApiCreateCustomFileFromUploadRequest {
+    data: CreateCustomFileData;
+}
+export interface PDFApiCreateDataRequestEventRequest {
+    dataRequestId: string;
+    event: CreateSubmissionDataRequestEventRequest;
+}
+export interface PDFApiCreateDataRequestTokenRequest {
+    dataRequestId: string;
+    type?: 'api' | 'email';
+}
+export interface PDFApiCreateFolderRequest {
+    data: CreateFolderData;
+}
+export interface PDFApiCreateHTMLTemplateRequest {
+    data: CreateHtmlTemplate;
+}
+export interface PDFApiCreatePDFTemplateRequest {
+    templateDocument: HttpFile;
+    templateName: string;
+    wait?: boolean;
+    templateDescription?: string;
+    templateParentFolderId?: string;
+}
+export interface PDFApiCreatePDFTemplateFromUploadRequest {
+    data: CreatePdfTemplate;
+}
+export interface PDFApiDeleteFolderRequest {
+    folderId: string;
+}
+export interface PDFApiDeleteTemplateRequest {
+    templateId: string;
+}
+export interface PDFApiExpireCombinedSubmissionRequest {
+    combinedSubmissionId: string;
+}
+export interface PDFApiExpireSubmissionRequest {
+    submissionId: string;
+}
+export interface PDFApiGeneratePdfRequest {
+    templateId: string;
+    submission: CreatePdfSubmissionData;
+    wait?: boolean;
+}
+export interface PDFApiGeneratePdfForHtmlTemplateRequest {
+    templateId: string;
+    submission: CreateHtmlSubmissionData;
+    wait?: boolean;
+}
+export interface PDFApiGeneratePreviewRequest {
+    submissionId: string;
+}
+export interface PDFApiGetCombinedSubmissionRequest {
+    combinedSubmissionId: string;
+}
+export interface PDFApiGetDataRequestRequest {
+    dataRequestId: string;
+}
+export interface PDFApiGetFullTemplateRequest {
+    templateId: string;
+}
+export interface PDFApiGetPresignUrlRequest {
+}
+export interface PDFApiGetSubmissionRequest {
+    submissionId: string;
+    includeData?: boolean;
+}
+export interface PDFApiGetSubmissionBatchRequest {
+    submissionBatchId: string;
+    includeSubmissions?: boolean;
+}
+export interface PDFApiGetTemplateRequest {
+    templateId: string;
+}
+export interface PDFApiGetTemplateSchemaRequest {
+    templateId: string;
+}
+export interface PDFApiListCombinedSubmissionsRequest {
+    page?: number;
+    perPage?: number;
+}
+export interface PDFApiListFoldersRequest {
+    parentFolderId?: string;
+}
+export interface PDFApiListSubmissionsRequest {
+    cursor?: string;
+    limit?: number;
+    createdAfter?: string;
+    createdBefore?: string;
+    type?: string;
+    includeData?: boolean;
+}
+export interface PDFApiListTemplateSubmissionsRequest {
+    templateId: string;
+    cursor?: string;
+    limit?: number;
+    createdAfter?: string;
+    createdBefore?: string;
+    type?: string;
+    includeData?: boolean;
+}
+export interface PDFApiListTemplatesRequest {
+    query?: string;
+    parentFolderId?: string;
+    page?: number;
+    perPage?: number;
+}
+export interface PDFApiMoveFolderToFolderRequest {
+    folderId: string;
+    data: MoveFolderData;
+}
+export interface PDFApiMoveTemplateToFolderRequest {
+    templateId: string;
+    data: MoveTemplateData;
+}
+export interface PDFApiRenameFolderRequest {
+    folderId: string;
+    data: RenameFolderData;
+}
+export interface PDFApiTestAuthenticationRequest {
+}
+export interface PDFApiUpdateDataRequestRequest {
+    dataRequestId: string;
+    data: UpdateSubmissionDataRequestData;
+}
+export interface PDFApiUpdateTemplateRequest {
+    templateId: string;
+    data: UpdateHtmlTemplate;
+}
+export declare class ObjectPDFApi {
+    private api;
+    constructor(configuration: Configuration, requestFactory?: PDFApiRequestFactory, responseProcessor?: PDFApiResponseProcessor);
+    addFieldsToTemplateWithHttpInfo(param: PDFApiAddFieldsToTemplateRequest, options?: Configuration): Promise<HttpInfo<TemplateAddFieldsResponse>>;
+    addFieldsToTemplate(param: PDFApiAddFieldsToTemplateRequest, options?: Configuration): Promise<TemplateAddFieldsResponse>;
+    batchGeneratePdfsWithHttpInfo(param: PDFApiBatchGeneratePdfsRequest, options?: Configuration): Promise<HttpInfo<BatchGeneratePdfs201Response>>;
+    batchGeneratePdfs(param: PDFApiBatchGeneratePdfsRequest, options?: Configuration): Promise<BatchGeneratePdfs201Response>;
+    combinePdfsWithHttpInfo(param: PDFApiCombinePdfsRequest, options?: Configuration): Promise<HttpInfo<CreateCombinedSubmissionResponse>>;
+    combinePdfs(param: PDFApiCombinePdfsRequest, options?: Configuration): Promise<CreateCombinedSubmissionResponse>;
+    combineSubmissionsWithHttpInfo(param: PDFApiCombineSubmissionsRequest, options?: Configuration): Promise<HttpInfo<CreateCombinedSubmissionResponse>>;
+    combineSubmissions(param: PDFApiCombineSubmissionsRequest, options?: Configuration): Promise<CreateCombinedSubmissionResponse>;
+    copyTemplateWithHttpInfo(param: PDFApiCopyTemplateRequest, options?: Configuration): Promise<HttpInfo<TemplatePreview>>;
+    copyTemplate(param: PDFApiCopyTemplateRequest, options?: Configuration): Promise<TemplatePreview>;
+    createCustomFileFromUploadWithHttpInfo(param: PDFApiCreateCustomFileFromUploadRequest, options?: Configuration): Promise<HttpInfo<CreateCustomFileResponse>>;
+    createCustomFileFromUpload(param: PDFApiCreateCustomFileFromUploadRequest, options?: Configuration): Promise<CreateCustomFileResponse>;
+    createDataRequestEventWithHttpInfo(param: PDFApiCreateDataRequestEventRequest, options?: Configuration): Promise<HttpInfo<CreateSubmissionDataRequestEventResponse>>;
+    createDataRequestEvent(param: PDFApiCreateDataRequestEventRequest, options?: Configuration): Promise<CreateSubmissionDataRequestEventResponse>;
+    createDataRequestTokenWithHttpInfo(param: PDFApiCreateDataRequestTokenRequest, options?: Configuration): Promise<HttpInfo<CreateSubmissionDataRequestTokenResponse>>;
+    createDataRequestToken(param: PDFApiCreateDataRequestTokenRequest, options?: Configuration): Promise<CreateSubmissionDataRequestTokenResponse>;
+    createFolderWithHttpInfo(param: PDFApiCreateFolderRequest, options?: Configuration): Promise<HttpInfo<Folder>>;
+    createFolder(param: PDFApiCreateFolderRequest, options?: Configuration): Promise<Folder>;
+    createHTMLTemplateWithHttpInfo(param: PDFApiCreateHTMLTemplateRequest, options?: Configuration): Promise<HttpInfo<TemplatePreview>>;
+    createHTMLTemplate(param: PDFApiCreateHTMLTemplateRequest, options?: Configuration): Promise<TemplatePreview>;
+    createPDFTemplateWithHttpInfo(param: PDFApiCreatePDFTemplateRequest, options?: Configuration): Promise<HttpInfo<TemplatePreview>>;
+    createPDFTemplate(param: PDFApiCreatePDFTemplateRequest, options?: Configuration): Promise<TemplatePreview>;
+    createPDFTemplateFromUploadWithHttpInfo(param: PDFApiCreatePDFTemplateFromUploadRequest, options?: Configuration): Promise<HttpInfo<TemplatePreview>>;
+    createPDFTemplateFromUpload(param: PDFApiCreatePDFTemplateFromUploadRequest, options?: Configuration): Promise<TemplatePreview>;
+    deleteFolderWithHttpInfo(param: PDFApiDeleteFolderRequest, options?: Configuration): Promise<HttpInfo<Folder>>;
+    deleteFolder(param: PDFApiDeleteFolderRequest, options?: Configuration): Promise<Folder>;
+    deleteTemplateWithHttpInfo(param: PDFApiDeleteTemplateRequest, options?: Configuration): Promise<HttpInfo<SuccessMultipleErrorsResponse>>;
+    deleteTemplate(param: PDFApiDeleteTemplateRequest, options?: Configuration): Promise<SuccessMultipleErrorsResponse>;
+    expireCombinedSubmissionWithHttpInfo(param: PDFApiExpireCombinedSubmissionRequest, options?: Configuration): Promise<HttpInfo<CombinedSubmission>>;
+    expireCombinedSubmission(param: PDFApiExpireCombinedSubmissionRequest, options?: Configuration): Promise<CombinedSubmission>;
+    expireSubmissionWithHttpInfo(param: PDFApiExpireSubmissionRequest, options?: Configuration): Promise<HttpInfo<SubmissionPreview>>;
+    expireSubmission(param: PDFApiExpireSubmissionRequest, options?: Configuration): Promise<SubmissionPreview>;
+    generatePdfWithHttpInfo(param: PDFApiGeneratePdfRequest, options?: Configuration): Promise<HttpInfo<CreateSubmissionResponse>>;
+    generatePdf(param: PDFApiGeneratePdfRequest, options?: Configuration): Promise<CreateSubmissionResponse>;
+    generatePdfForHtmlTemplateWithHttpInfo(param: PDFApiGeneratePdfForHtmlTemplateRequest, options?: Configuration): Promise<HttpInfo<CreateSubmissionResponse>>;
+    generatePdfForHtmlTemplate(param: PDFApiGeneratePdfForHtmlTemplateRequest, options?: Configuration): Promise<CreateSubmissionResponse>;
+    generatePreviewWithHttpInfo(param: PDFApiGeneratePreviewRequest, options?: Configuration): Promise<HttpInfo<SuccessErrorResponse>>;
+    generatePreview(param: PDFApiGeneratePreviewRequest, options?: Configuration): Promise<SuccessErrorResponse>;
+    getCombinedSubmissionWithHttpInfo(param: PDFApiGetCombinedSubmissionRequest, options?: Configuration): Promise<HttpInfo<CombinedSubmission>>;
+    getCombinedSubmission(param: PDFApiGetCombinedSubmissionRequest, options?: Configuration): Promise<CombinedSubmission>;
+    getDataRequestWithHttpInfo(param: PDFApiGetDataRequestRequest, options?: Configuration): Promise<HttpInfo<SubmissionDataRequestShow>>;
+    getDataRequest(param: PDFApiGetDataRequestRequest, options?: Configuration): Promise<SubmissionDataRequestShow>;
+    getFullTemplateWithHttpInfo(param: PDFApiGetFullTemplateRequest, options?: Configuration): Promise<HttpInfo<Template>>;
+    getFullTemplate(param: PDFApiGetFullTemplateRequest, options?: Configuration): Promise<Template>;
+    getPresignUrlWithHttpInfo(param?: PDFApiGetPresignUrlRequest, options?: Configuration): Promise<HttpInfo<UploadPresignResponse>>;
+    getPresignUrl(param?: PDFApiGetPresignUrlRequest, options?: Configuration): Promise<UploadPresignResponse>;
+    getSubmissionWithHttpInfo(param: PDFApiGetSubmissionRequest, options?: Configuration): Promise<HttpInfo<Submission>>;
+    getSubmission(param: PDFApiGetSubmissionRequest, options?: Configuration): Promise<Submission>;
+    getSubmissionBatchWithHttpInfo(param: PDFApiGetSubmissionBatchRequest, options?: Configuration): Promise<HttpInfo<SubmissionBatchWithSubmissions>>;
+    getSubmissionBatch(param: PDFApiGetSubmissionBatchRequest, options?: Configuration): Promise<SubmissionBatchWithSubmissions>;
+    getTemplateWithHttpInfo(param: PDFApiGetTemplateRequest, options?: Configuration): Promise<HttpInfo<TemplatePreview>>;
+    getTemplate(param: PDFApiGetTemplateRequest, options?: Configuration): Promise<TemplatePreview>;
+    getTemplateSchemaWithHttpInfo(param: PDFApiGetTemplateSchemaRequest, options?: Configuration): Promise<HttpInfo<JsonSchema>>;
+    getTemplateSchema(param: PDFApiGetTemplateSchemaRequest, options?: Configuration): Promise<JsonSchema>;
+    listCombinedSubmissionsWithHttpInfo(param?: PDFApiListCombinedSubmissionsRequest, options?: Configuration): Promise<HttpInfo<Array<CombinedSubmission>>>;
+    listCombinedSubmissions(param?: PDFApiListCombinedSubmissionsRequest, options?: Configuration): Promise<Array<CombinedSubmission>>;
+    listFoldersWithHttpInfo(param?: PDFApiListFoldersRequest, options?: Configuration): Promise<HttpInfo<Array<Folder>>>;
+    listFolders(param?: PDFApiListFoldersRequest, options?: Configuration): Promise<Array<Folder>>;
+    listSubmissionsWithHttpInfo(param?: PDFApiListSubmissionsRequest, options?: Configuration): Promise<HttpInfo<ListSubmissionsResponse>>;
+    listSubmissions(param?: PDFApiListSubmissionsRequest, options?: Configuration): Promise<ListSubmissionsResponse>;
+    listTemplateSubmissionsWithHttpInfo(param: PDFApiListTemplateSubmissionsRequest, options?: Configuration): Promise<HttpInfo<ListSubmissionsResponse>>;
+    listTemplateSubmissions(param: PDFApiListTemplateSubmissionsRequest, options?: Configuration): Promise<ListSubmissionsResponse>;
+    listTemplatesWithHttpInfo(param?: PDFApiListTemplatesRequest, options?: Configuration): Promise<HttpInfo<Array<TemplatePreview>>>;
+    listTemplates(param?: PDFApiListTemplatesRequest, options?: Configuration): Promise<Array<TemplatePreview>>;
+    moveFolderToFolderWithHttpInfo(param: PDFApiMoveFolderToFolderRequest, options?: Configuration): Promise<HttpInfo<Folder>>;
+    moveFolderToFolder(param: PDFApiMoveFolderToFolderRequest, options?: Configuration): Promise<Folder>;
+    moveTemplateToFolderWithHttpInfo(param: PDFApiMoveTemplateToFolderRequest, options?: Configuration): Promise<HttpInfo<TemplatePreview>>;
+    moveTemplateToFolder(param: PDFApiMoveTemplateToFolderRequest, options?: Configuration): Promise<TemplatePreview>;
+    renameFolderWithHttpInfo(param: PDFApiRenameFolderRequest, options?: Configuration): Promise<HttpInfo<Folder>>;
+    renameFolder(param: PDFApiRenameFolderRequest, options?: Configuration): Promise<Folder>;
+    testAuthenticationWithHttpInfo(param?: PDFApiTestAuthenticationRequest, options?: Configuration): Promise<HttpInfo<SuccessErrorResponse>>;
+    testAuthentication(param?: PDFApiTestAuthenticationRequest, options?: Configuration): Promise<SuccessErrorResponse>;
+    updateDataRequestWithHttpInfo(param: PDFApiUpdateDataRequestRequest, options?: Configuration): Promise<HttpInfo<CreateSubmissionDataRequestResponse>>;
+    updateDataRequest(param: PDFApiUpdateDataRequestRequest, options?: Configuration): Promise<CreateSubmissionDataRequestResponse>;
+    updateTemplateWithHttpInfo(param: PDFApiUpdateTemplateRequest, options?: Configuration): Promise<HttpInfo<SuccessMultipleErrorsResponse>>;
+    updateTemplate(param: PDFApiUpdateTemplateRequest, options?: Configuration): Promise<SuccessMultipleErrorsResponse>;
+}