@digital8/lighting-illusions-ts-sdk 0.0.979 → 0.0.981

package/dist/apis/DefinitionApi.d.ts

@@ -34,6 +34,10 @@ export interface UpdateDefinitionOperationRequest {
  *
  */
 export declare class DefinitionApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for destroyDefinition without sending the request
+     */
+    destroyDefinitionRequestOpts(requestParameters: DestroyDefinitionRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: destroyDefinition
      */
@@ -42,6 +46,10 @@ export declare class DefinitionApi extends runtime.BaseAPI {
      * Auto-generated: destroyDefinition
      */
     destroyDefinition(requestParameters: DestroyDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GenericResponse>;
+    /**
+     * Creates request options for getAllDefinition without sending the request
+     */
+    getAllDefinitionRequestOpts(requestParameters: GetAllDefinitionOperationRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: getAllDefinition
      */
@@ -50,6 +58,10 @@ export declare class DefinitionApi extends runtime.BaseAPI {
      * Auto-generated: getAllDefinition
      */
     getAllDefinition(requestParameters?: GetAllDefinitionOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DefinitionListResourceArrayResponse>;
+    /**
+     * Creates request options for indexDefinition without sending the request
+     */
+    indexDefinitionRequestOpts(requestParameters: IndexDefinitionOperationRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: indexDefinition
      */
@@ -58,6 +70,10 @@ export declare class DefinitionApi extends runtime.BaseAPI {
      * Auto-generated: indexDefinition
      */
     indexDefinition(requestParameters?: IndexDefinitionOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedDefinitionListResourceResponse>;
+    /**
+     * Creates request options for showDefinition without sending the request
+     */
+    showDefinitionRequestOpts(requestParameters: ShowDefinitionRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: showDefinition
      */
@@ -66,6 +82,10 @@ export declare class DefinitionApi extends runtime.BaseAPI {
      * Auto-generated: showDefinition
      */
     showDefinition(requestParameters: ShowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DefinitionResource>;
+    /**
+     * Creates request options for storeDefinition without sending the request
+     */
+    storeDefinitionRequestOpts(requestParameters: StoreDefinitionOperationRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: storeDefinition
      */
@@ -74,6 +94,10 @@ export declare class DefinitionApi extends runtime.BaseAPI {
      * Auto-generated: storeDefinition
      */
     storeDefinition(requestParameters?: StoreDefinitionOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DefinitionResource>;
+    /**
+     * Creates request options for updateDefinition without sending the request
+     */
+    updateDefinitionRequestOpts(requestParameters: UpdateDefinitionOperationRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: updateDefinition
      */

package/dist/apis/DefinitionApi.js

@@ -75,29 +75,42 @@ var DefinitionApi = /** @class */ (function (_super) {
     function DefinitionApi() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * Creates request options for destroyDefinition without sending the request
+     */
+    DefinitionApi.prototype.destroyDefinitionRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['definition'] == null) {
+                    throw new runtime.RequiredError('definition', 'Required parameter "definition" was null or undefined when calling destroyDefinition().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/admin-api/definition/{definition}/delete";
+                urlPath = urlPath.replace("{".concat("definition", "}"), encodeURIComponent(String(requestParameters['definition'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'DELETE',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * Auto-generated: destroyDefinition
      */
     DefinitionApi.prototype.destroyDefinitionRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, urlPath, response;
+            var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        if (requestParameters['definition'] == null) {
-                            throw new runtime.RequiredError('definition', 'Required parameter "definition" was null or undefined when calling destroyDefinition().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/admin-api/definition/{definition}/delete";
-                        urlPath = urlPath.replace("{".concat("definition", "}"), encodeURIComponent(String(requestParameters['definition'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'DELETE',
-                                headers: headerParameters,
-                                query: queryParameters,
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.destroyDefinitionRequestOpts(requestParameters)];
                     case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
                         response = _a.sent();
                         return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.GenericResponseFromJSON)(jsonValue); })];
                 }
@@ -121,27 +134,40 @@ var DefinitionApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for getAllDefinition without sending the request
+     */
+    DefinitionApi.prototype.getAllDefinitionRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/admin-api/definition/all";
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, index_1.GetAllDefinitionRequestToJSON)(requestParameters['getAllDefinitionRequest']),
+                    }];
+            });
+        });
+    };
     /**
      * Auto-generated: getAllDefinition
      */
     DefinitionApi.prototype.getAllDefinitionRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, urlPath, response;
+            var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        queryParameters = {};
-                        headerParameters = {};
-                        headerParameters['Content-Type'] = 'application/json';
-                        urlPath = "/admin-api/definition/all";
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'POST',
-                                headers: headerParameters,
-                                query: queryParameters,
-                                body: (0, index_1.GetAllDefinitionRequestToJSON)(requestParameters['getAllDefinitionRequest']),
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.getAllDefinitionRequestOpts(requestParameters)];
                     case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
                         response = _a.sent();
                         return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.DefinitionListResourceArrayResponseFromJSON)(jsonValue); })];
                 }
@@ -166,27 +192,40 @@ var DefinitionApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for indexDefinition without sending the request
+     */
+    DefinitionApi.prototype.indexDefinitionRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/admin-api/definition/list";
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, index_1.IndexDefinitionRequestToJSON)(requestParameters['indexDefinitionRequest']),
+                    }];
+            });
+        });
+    };
     /**
      * Auto-generated: indexDefinition
      */
     DefinitionApi.prototype.indexDefinitionRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, urlPath, response;
+            var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        queryParameters = {};
-                        headerParameters = {};
-                        headerParameters['Content-Type'] = 'application/json';
-                        urlPath = "/admin-api/definition/list";
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'POST',
-                                headers: headerParameters,
-                                query: queryParameters,
-                                body: (0, index_1.IndexDefinitionRequestToJSON)(requestParameters['indexDefinitionRequest']),
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.indexDefinitionRequestOpts(requestParameters)];
                     case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
                         response = _a.sent();
                         return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.PaginatedDefinitionListResourceResponseFromJSON)(jsonValue); })];
                 }
@@ -211,29 +250,42 @@ var DefinitionApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for showDefinition without sending the request
+     */
+    DefinitionApi.prototype.showDefinitionRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['definition'] == null) {
+                    throw new runtime.RequiredError('definition', 'Required parameter "definition" was null or undefined when calling showDefinition().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/admin-api/definition/{definition}";
+                urlPath = urlPath.replace("{".concat("definition", "}"), encodeURIComponent(String(requestParameters['definition'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
     /**
      * Auto-generated: showDefinition
      */
     DefinitionApi.prototype.showDefinitionRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, urlPath, response;
+            var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        if (requestParameters['definition'] == null) {
-                            throw new runtime.RequiredError('definition', 'Required parameter "definition" was null or undefined when calling showDefinition().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        urlPath = "/admin-api/definition/{definition}";
-                        urlPath = urlPath.replace("{".concat("definition", "}"), encodeURIComponent(String(requestParameters['definition'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'GET',
-                                headers: headerParameters,
-                                query: queryParameters,
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.showDefinitionRequestOpts(requestParameters)];
                     case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
                         response = _a.sent();
                         return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.DefinitionResourceFromJSON)(jsonValue); })];
                 }
@@ -257,27 +309,40 @@ var DefinitionApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for storeDefinition without sending the request
+     */
+    DefinitionApi.prototype.storeDefinitionRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/admin-api/definition/create";
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, index_1.StoreDefinitionRequestToJSON)(requestParameters['storeDefinitionRequest']),
+                    }];
+            });
+        });
+    };
     /**
      * Auto-generated: storeDefinition
      */
     DefinitionApi.prototype.storeDefinitionRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, urlPath, response;
+            var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        queryParameters = {};
-                        headerParameters = {};
-                        headerParameters['Content-Type'] = 'application/json';
-                        urlPath = "/admin-api/definition/create";
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'POST',
-                                headers: headerParameters,
-                                query: queryParameters,
-                                body: (0, index_1.StoreDefinitionRequestToJSON)(requestParameters['storeDefinitionRequest']),
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.storeDefinitionRequestOpts(requestParameters)];
                     case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
                         response = _a.sent();
                         return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.DefinitionResourceFromJSON)(jsonValue); })];
                 }
@@ -302,31 +367,44 @@ var DefinitionApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for updateDefinition without sending the request
+     */
+    DefinitionApi.prototype.updateDefinitionRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['definition'] == null) {
+                    throw new runtime.RequiredError('definition', 'Required parameter "definition" was null or undefined when calling updateDefinition().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/admin-api/definition/{definition}/update";
+                urlPath = urlPath.replace("{".concat("definition", "}"), encodeURIComponent(String(requestParameters['definition'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'PUT',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, index_1.UpdateDefinitionRequestToJSON)(requestParameters['updateDefinitionRequest']),
+                    }];
+            });
+        });
+    };
     /**
      * Auto-generated: updateDefinition
      */
     DefinitionApi.prototype.updateDefinitionRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, urlPath, response;
+            var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        if (requestParameters['definition'] == null) {
-                            throw new runtime.RequiredError('definition', 'Required parameter "definition" was null or undefined when calling updateDefinition().');
-                        }
-                        queryParameters = {};
-                        headerParameters = {};
-                        headerParameters['Content-Type'] = 'application/json';
-                        urlPath = "/admin-api/definition/{definition}/update";
-                        urlPath = urlPath.replace("{".concat("definition", "}"), encodeURIComponent(String(requestParameters['definition'])));
-                        return [4 /*yield*/, this.request({
-                                path: urlPath,
-                                method: 'PUT',
-                                headers: headerParameters,
-                                query: queryParameters,
-                                body: (0, index_1.UpdateDefinitionRequestToJSON)(requestParameters['updateDefinitionRequest']),
-                            }, initOverrides)];
+                    case 0: return [4 /*yield*/, this.updateDefinitionRequestOpts(requestParameters)];
                     case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
                         response = _a.sent();
                         return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.DefinitionResourceFromJSON)(jsonValue); })];
                 }

package/dist/apis/DocumentApi.d.ts

@@ -45,6 +45,10 @@ export interface UpdateDocumentOperationRequest {
  *
  */
 export declare class DocumentApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for attachDocumentablesDocument without sending the request
+     */
+    attachDocumentablesDocumentRequestOpts(requestParameters: AttachDocumentablesDocumentOperationRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: attachDocumentablesDocument
      */
@@ -53,6 +57,10 @@ export declare class DocumentApi extends runtime.BaseAPI {
      * Auto-generated: attachDocumentablesDocument
      */
     attachDocumentablesDocument(requestParameters: AttachDocumentablesDocumentOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DocumentResource>;
+    /**
+     * Creates request options for destroyDocument without sending the request
+     */
+    destroyDocumentRequestOpts(requestParameters: DestroyDocumentRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: destroyDocument
      */
@@ -61,6 +69,10 @@ export declare class DocumentApi extends runtime.BaseAPI {
      * Auto-generated: destroyDocument
      */
     destroyDocument(requestParameters: DestroyDocumentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GenericResponse>;
+    /**
+     * Creates request options for detachDocumentablesDocument without sending the request
+     */
+    detachDocumentablesDocumentRequestOpts(requestParameters: DetachDocumentablesDocumentOperationRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: detachDocumentablesDocument
      */
@@ -69,6 +81,10 @@ export declare class DocumentApi extends runtime.BaseAPI {
      * Auto-generated: detachDocumentablesDocument
      */
     detachDocumentablesDocument(requestParameters: DetachDocumentablesDocumentOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DocumentResource>;
+    /**
+     * Creates request options for getAllDocument without sending the request
+     */
+    getAllDocumentRequestOpts(requestParameters: GetAllDocumentOperationRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: getAllDocument
      */
@@ -77,6 +93,10 @@ export declare class DocumentApi extends runtime.BaseAPI {
      * Auto-generated: getAllDocument
      */
     getAllDocument(requestParameters?: GetAllDocumentOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DocumentResourceArrayResponse>;
+    /**
+     * Creates request options for indexDocument without sending the request
+     */
+    indexDocumentRequestOpts(requestParameters: IndexDocumentOperationRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: indexDocument
      */
@@ -85,6 +105,10 @@ export declare class DocumentApi extends runtime.BaseAPI {
      * Auto-generated: indexDocument
      */
     indexDocument(requestParameters?: IndexDocumentOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedDocumentResourceResponse>;
+    /**
+     * Creates request options for showDocument without sending the request
+     */
+    showDocumentRequestOpts(requestParameters: ShowDocumentRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: showDocument
      */
@@ -93,6 +117,10 @@ export declare class DocumentApi extends runtime.BaseAPI {
      * Auto-generated: showDocument
      */
     showDocument(requestParameters: ShowDocumentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DocumentResource>;
+    /**
+     * Creates request options for storeDocument without sending the request
+     */
+    storeDocumentRequestOpts(requestParameters: StoreDocumentOperationRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: storeDocument
      */
@@ -101,6 +129,10 @@ export declare class DocumentApi extends runtime.BaseAPI {
      * Auto-generated: storeDocument
      */
     storeDocument(requestParameters?: StoreDocumentOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DocumentResource>;
+    /**
+     * Creates request options for storeDocumentFile without sending the request
+     */
+    storeDocumentFileRequestOpts(requestParameters: StoreDocumentFileOperationRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: storeDocumentFile
      */
@@ -109,6 +141,10 @@ export declare class DocumentApi extends runtime.BaseAPI {
      * Auto-generated: storeDocumentFile
      */
     storeDocumentFile(requestParameters?: StoreDocumentFileOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DocumentFileForUploadResource>;
+    /**
+     * Creates request options for updateDocument without sending the request
+     */
+    updateDocumentRequestOpts(requestParameters: UpdateDocumentOperationRequest): Promise<runtime.RequestOpts>;
     /**
      * Auto-generated: updateDocument
      */