unstructured-transform-client 0.18.18

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Unstructured-IO
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,210 @@
+# unstructured-transform-client
+
+TypeScript client for the [Unstructured](https://unstructured.io) Transform v2
+API. One document in, structured output back.
+
+```ts
+import { TransformClient, isAccepted } from "unstructured-transform-client";
+
+const client = new TransformClient(); // reads UNSTRUCTURED_API_KEY in Node
+const outcome = await client.parse.run({ input: file }); // a File, from an <input>
+if (!isAccepted(outcome)) console.log(outcome.body.markdown);
+```
+
+## Install
+
+Install from public npm:
+
+```bash
+npm install unstructured-transform-client
+```
+
+Set `UNSTRUCTURED_API_KEY` for the default API-key authentication path:
+
+```bash
+export UNSTRUCTURED_API_KEY="your-key-here"
+```
+
+In Node, create the client without passing a key. An explicit `apiKey` takes
+precedence over the environment variable; pass `bearerToken` explicitly for
+bearer authentication. If neither is available, construction raises an error
+naming `UNSTRUCTURED_API_KEY`.
+
+Requires Node 22 or newer, for native `fetch` and `FormData`.
+
+## The three flows
+
+**Parse a document.**
+
+```ts
+const outcome = await client.parse.run({ input: file });
+```
+
+Every submitting call answers **either** a finished result (200) **or** a job
+handle (202) — `waitSeconds: 0` always produces the latter. So they return a
+discriminated union rather than pretending the second is the first:
+
+```ts
+if (isAccepted(outcome)) {
+  for await (const event of client.jobs.stream(outcome.body.id)) { /* ... */ }
+} else {
+  console.log(outcome.body.markdown);
+}
+```
+
+**Extract fields from a document in one call.** Supplying a schema adds an
+extraction step to the same job, so the document is parsed once.
+
+```ts
+const outcome = await client.parse.run({
+  input: file,
+  schema: {
+    type: "object",
+    properties: { invoiceNumber: { type: "string" } },
+    required: ["invoiceNumber"],
+    additionalProperties: false,
+  },
+});
+```
+
+The engine requires `required` to list every key in `properties` and
+`additionalProperties` to be `false`. That constraint cannot be expressed in
+OpenAPI, so the types do not enforce it — a schema without it is rejected at
+request time rather than by the compiler.
+
+**Extract against a parse you already have.**
+
+```ts
+const extraction = await client.extract.run({ parseId, schema });
+```
+
+`extract.fromDocument` also takes `fileId` instead of `input`, for a document
+already uploaded.
+
+An extraction is a job like any other. If the call returns an accepted job,
+follow it to a terminal status before reading `result.extractedData`. A
+single `jobs.get` right after submitting can still land on `queued` or
+`processing`, with `result` still `undefined`:
+
+```ts
+const outcome = await client.extract.run({ parseId, schema, waitSeconds: 0 });
+if (isAccepted(outcome)) {
+  const deadline = Date.now() + 300_000;
+  let job = await client.jobs.get(outcome.body.id);
+  while (job.status === "queued" || job.status === "processing") {
+    if (Date.now() >= deadline) {
+      throw new Error(`extraction ${outcome.body.id} is still ${job.status}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    job = await client.jobs.get(outcome.body.id);
+  }
+  console.log(job.status, job.result?.extractedData);
+}
+```
+
+Give the wait a bound, as above. A job can stay queued or processing, and a
+loop without a deadline polls forever. `jobs.stream` is the alternative: it
+ends on its own at the terminal event, and is shown under Long-running jobs
+below.
+
+## Long-running jobs
+
+Pass `waitSeconds` to block, or `waitSeconds: 0` to take a job handle and
+follow it yourself.
+
+```ts
+const job = await client.parse.run({ input: file, waitSeconds: 0 });
+
+for await (const event of client.jobs.stream(job.body.id)) {
+  console.log(event.event, event.data);
+}
+```
+
+The stream yields `status` events and then exactly one terminal `result` or
+`error`, after which it ends on its own. Pass an `AbortSignal` to stop early:
+
+```ts
+const controller = new AbortController();
+for await (const event of client.jobs.stream(job.body.id, { signal: controller.signal })) {
+  if (someCondition) controller.abort();
+}
+```
+
+Polling with `client.jobs.get(job.body.id)` returns the same resource if you would
+rather not hold a connection open.
+
+To scan jobs across every page, use the cursor-following async iterator.
+`list()` still returns one page when you need page boundaries.
+
+```ts
+for await (const job of client.jobs.iterate({ status: "completed" })) {
+  console.log(job.id, job.status);
+}
+```
+
+## Retries
+
+Retries are enabled by default for transient failures. Configure them per
+client, or pass `retries: false` to disable them:
+
+```ts
+const client = new TransformClient({
+  retries: { maxAttempts: 5, maxElapsedMs: 20_000 },
+});
+const withoutRetries = new TransformClient({ retries: false });
+```
+
+`GET` and `DELETE` are retried on any transient failure. Everything else — a
+parse, extract or upload submit, and any other write — is retried only when the
+failure proves the request never reached the service, such as a refused
+connection or a DNS failure. A read timeout or a `5xx` on a write is not
+retried, because the service may have acted on it already and a second attempt
+could duplicate the effect.
+
+## Documents need a filename
+
+Pass a `File`, or `{ data, filename }`. A bare `Blob` is refused:
+
+```ts
+await client.parse.run({ input: new File([bytes], "invoice.pdf") });
+await client.parse.run({ input: { data: bytes, filename: "invoice.pdf" } });
+```
+
+The service validates an upload's extension against an allowlist, and a
+`FormData` part built from an unnamed `Blob` arrives called `blob` — so it
+would be rejected as an unsupported file type. Refusing it here names the real
+problem instead.
+
+## Credentials
+
+Pass exactly one of `apiKey` or `bearerToken`. They are different identities,
+not two spellings of one credential — whichever you send is forwarded upstream
+as-is.
+
+## What this client tells us about your environment
+
+Every request carries a `User-Agent` and a set of `X-Unstructured-Client-*`
+headers: this package's version, the language, your Node version, your OS
+family, and your CPU architecture.
+
+It never sends your hostname, username, working directory, environment
+variables, IP address, or anything read from your documents. In a browser it
+reports neither OS nor architecture, and the `User-Agent` is set by the browser
+rather than by this package.
+
+To send only the `User-Agent`:
+
+```ts
+const client = new TransformClient({ apiKey: "...", sendHostHeaders: false });
+```
+
+or set `UNSTRUCTURED_TRANSFORM_DISABLE_HOST_HEADERS=1`.
+
+## Versioning
+
+This client's version tracks the Transform API revision it was generated from,
+so `0.18.x` of this package describes `0.18.x` of the API.
+
+Everything exported from the package root is public. The `_generated` directory
+is not — it is produced from the OpenAPI contract at build time and may be
+reorganised without notice.

package/dist/_generated/apis/ExtractApi.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Unstructured Transform API
+ * One document in, the parsed document back. A single call takes a document and returns structured output — no job graph, no strategy selection, no model provider setup, and no polling loop. An optional schema switches the request from parse-only to parse-then-extract.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime.js';
+import { type ExtractRequest } from '../models/ExtractRequest.js';
+import { type ParseResult } from '../models/ParseResult.js';
+export interface ExtractRunRequest {
+    /**
+     *
+     */
+    extractRequest: ExtractRequest;
+    /**
+     * Wait up to this many seconds for completed extraction.
+     */
+    prefer?: string;
+}
+/**
+ *
+ */
+export declare class ExtractApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for extractRun without sending the request
+     */
+    extractRunRequestOpts(requestParameters: ExtractRunRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Takes either a parse ID or a document and a schema, then returns the fields. A multipart input is limited to 50 MB and to the supported extensions: bmp, docx, heic, jpeg, jpg, pdf, png, pptx, tiff.
+     * Extract fields from a parse or document
+     */
+    extractRunRaw(requestParameters: ExtractRunRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ParseResult>>;
+    /**
+     * Takes either a parse ID or a document and a schema, then returns the fields. A multipart input is limited to 50 MB and to the supported extensions: bmp, docx, heic, jpeg, jpg, pdf, png, pptx, tiff.
+     * Extract fields from a parse or document
+     */
+    extractRun(requestParameters: ExtractRunRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ParseResult>;
+}

package/dist/_generated/apis/ExtractApi.js

@@ -0,0 +1,70 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Unstructured Transform API
+ * One document in, the parsed document back. A single call takes a document and returns structured output — no job graph, no strategy selection, no model provider setup, and no polling loop. An optional schema switches the request from parse-only to parse-then-extract.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime.js';
+import { ExtractRequestToJSON, } from '../models/ExtractRequest.js';
+import { ParseResultFromJSON, } from '../models/ParseResult.js';
+/**
+ *
+ */
+export class ExtractApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for extractRun without sending the request
+     */
+    async extractRunRequestOpts(requestParameters) {
+        if (requestParameters['extractRequest'] == null) {
+            throw new runtime.RequiredError('extractRequest', 'Required parameter "extractRequest" was null or undefined when calling extractRun().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['prefer'] != null) {
+            headerParameters['Prefer'] = String(requestParameters['prefer']);
+        }
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["unstructured-api-key"] = await this.configuration.apiKey("unstructured-api-key"); // ApiKeyAuth authentication
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v2/extract`;
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ExtractRequestToJSON(requestParameters['extractRequest']),
+        };
+    }
+    /**
+     * Takes either a parse ID or a document and a schema, then returns the fields. A multipart input is limited to 50 MB and to the supported extensions: bmp, docx, heic, jpeg, jpg, pdf, png, pptx, tiff.
+     * Extract fields from a parse or document
+     */
+    async extractRunRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.extractRunRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => ParseResultFromJSON(jsonValue));
+    }
+    /**
+     * Takes either a parse ID or a document and a schema, then returns the fields. A multipart input is limited to 50 MB and to the supported extensions: bmp, docx, heic, jpeg, jpg, pdf, png, pptx, tiff.
+     * Extract fields from a parse or document
+     */
+    async extractRun(requestParameters, initOverrides) {
+        const response = await this.extractRunRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+}

package/dist/_generated/apis/JobsApi.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Unstructured Transform API
+ * One document in, the parsed document back. A single call takes a document and returns structured output — no job graph, no strategy selection, no model provider setup, and no polling loop. An optional schema switches the request from parse-only to parse-then-extract.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime.js';
+import { type JobPage } from '../models/JobPage.js';
+import { type JobResult } from '../models/JobResult.js';
+import { type JobStatus } from '../models/JobStatus.js';
+import { type OutputFormat } from '../models/OutputFormat.js';
+export interface JobsCancelRequest {
+    /**
+     *
+     */
+    jobId: string;
+}
+export interface JobsDeleteRequest {
+    /**
+     *
+     */
+    jobId: string;
+}
+export interface JobsGetRequest {
+    /**
+     *
+     */
+    jobId: string;
+    /**
+     *
+     */
+    output?: OutputFormat;
+    /**
+     * Optional list of projection fields to include in elements output. Allowed values are 'coordinates' and 'table_html'. Only valid when output='elements'.
+     */
+    include?: Array<string>;
+}
+export interface JobsListRequest {
+    /**
+     * Opaque pagination cursor from a previous response.
+     */
+    cursor?: string;
+    /**
+     * Maximum number of jobs to return.
+     */
+    limit?: number;
+    /**
+     * Return only jobs with this public status. completed_with_warnings maps to completed upstream and may include completed jobs without warnings.
+     */
+    status?: JobStatus;
+}
+/**
+ *
+ */
+export declare class JobsApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for jobsCancel without sending the request
+     */
+    jobsCancelRequestOpts(requestParameters: JobsCancelRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Requests cancellation of a queued or processing job. The response is the current job snapshot; poll this resource until its status is cancelled. Cancellation is idempotent and terminal jobs are unchanged.
+     * Request cancellation of a parse or extraction job
+     */
+    jobsCancelRaw(requestParameters: JobsCancelRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<JobResult>>;
+    /**
+     * Requests cancellation of a queued or processing job. The response is the current job snapshot; poll this resource until its status is cancelled. Cancellation is idempotent and terminal jobs are unchanged.
+     * Request cancellation of a parse or extraction job
+     */
+    jobsCancel(requestParameters: JobsCancelRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<JobResult>;
+    /**
+     * Creates request options for jobsDelete without sending the request
+     */
+    jobsDeleteRequestOpts(requestParameters: JobsDeleteRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Deletes a terminal job from the API\'s visible set. Deletion is asynchronous and idempotent. Source and output blobs follow retention policy and are not synchronously removed by this operation.
+     * Delete a completed parse or extraction job
+     */
+    jobsDeleteRaw(requestParameters: JobsDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Deletes a terminal job from the API\'s visible set. Deletion is asynchronous and idempotent. Source and output blobs follow retention policy and are not synchronously removed by this operation.
+     * Delete a completed parse or extraction job
+     */
+    jobsDelete(requestParameters: JobsDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for jobsGet without sending the request
+     */
+    jobsGetRequestOpts(requestParameters: JobsGetRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Returns the job\'s status, and its content as soon as it is available, for a job started by either parse or extract. An extraction job\'s fields arrive in result.extracted_data. Send Accept text/event-stream for progress events as the job runs, ending in one result event whose data is this same JobResult.
+     * Get the status or result of a parse or extraction job
+     */
+    jobsGetRaw(requestParameters: JobsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<JobResult>>;
+    /**
+     * Returns the job\'s status, and its content as soon as it is available, for a job started by either parse or extract. An extraction job\'s fields arrive in result.extracted_data. Send Accept text/event-stream for progress events as the job runs, ending in one result event whose data is this same JobResult.
+     * Get the status or result of a parse or extraction job
+     */
+    jobsGet(requestParameters: JobsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<JobResult>;
+    /**
+     * Creates request options for jobsList without sending the request
+     */
+    jobsListRequestOpts(requestParameters: JobsListRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Returns this caller\'s visible jobs, newest first. Tenant scope comes from the credential; the request has no tenant parameter.
+     * List parse and extraction jobs
+     */
+    jobsListRaw(requestParameters: JobsListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<JobPage>>;
+    /**
+     * Returns this caller\'s visible jobs, newest first. Tenant scope comes from the credential; the request has no tenant parameter.
+     * List parse and extraction jobs
+     */
+    jobsList(requestParameters?: JobsListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<JobPage>;
+}

package/dist/_generated/apis/JobsApi.js

@@ -0,0 +1,211 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Unstructured Transform API
+ * One document in, the parsed document back. A single call takes a document and returns structured output — no job graph, no strategy selection, no model provider setup, and no polling loop. An optional schema switches the request from parse-only to parse-then-extract.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime.js';
+import { JobPageFromJSON, } from '../models/JobPage.js';
+import { JobResultFromJSON, } from '../models/JobResult.js';
+/**
+ *
+ */
+export class JobsApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for jobsCancel without sending the request
+     */
+    async jobsCancelRequestOpts(requestParameters) {
+        if (requestParameters['jobId'] == null) {
+            throw new runtime.RequiredError('jobId', 'Required parameter "jobId" was null or undefined when calling jobsCancel().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["unstructured-api-key"] = await this.configuration.apiKey("unstructured-api-key"); // ApiKeyAuth authentication
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v2/jobs/{jobId}/cancel`;
+        urlPath = urlPath.replace('{jobId}', encodeURIComponent(String(requestParameters['jobId'])));
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Requests cancellation of a queued or processing job. The response is the current job snapshot; poll this resource until its status is cancelled. Cancellation is idempotent and terminal jobs are unchanged.
+     * Request cancellation of a parse or extraction job
+     */
+    async jobsCancelRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.jobsCancelRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => JobResultFromJSON(jsonValue));
+    }
+    /**
+     * Requests cancellation of a queued or processing job. The response is the current job snapshot; poll this resource until its status is cancelled. Cancellation is idempotent and terminal jobs are unchanged.
+     * Request cancellation of a parse or extraction job
+     */
+    async jobsCancel(requestParameters, initOverrides) {
+        const response = await this.jobsCancelRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for jobsDelete without sending the request
+     */
+    async jobsDeleteRequestOpts(requestParameters) {
+        if (requestParameters['jobId'] == null) {
+            throw new runtime.RequiredError('jobId', 'Required parameter "jobId" was null or undefined when calling jobsDelete().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["unstructured-api-key"] = await this.configuration.apiKey("unstructured-api-key"); // ApiKeyAuth authentication
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v2/jobs/{jobId}`;
+        urlPath = urlPath.replace('{jobId}', encodeURIComponent(String(requestParameters['jobId'])));
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Deletes a terminal job from the API\'s visible set. Deletion is asynchronous and idempotent. Source and output blobs follow retention policy and are not synchronously removed by this operation.
+     * Delete a completed parse or extraction job
+     */
+    async jobsDeleteRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.jobsDeleteRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.VoidApiResponse(response);
+    }
+    /**
+     * Deletes a terminal job from the API\'s visible set. Deletion is asynchronous and idempotent. Source and output blobs follow retention policy and are not synchronously removed by this operation.
+     * Delete a completed parse or extraction job
+     */
+    async jobsDelete(requestParameters, initOverrides) {
+        await this.jobsDeleteRaw(requestParameters, initOverrides);
+    }
+    /**
+     * Creates request options for jobsGet without sending the request
+     */
+    async jobsGetRequestOpts(requestParameters) {
+        if (requestParameters['jobId'] == null) {
+            throw new runtime.RequiredError('jobId', 'Required parameter "jobId" was null or undefined when calling jobsGet().');
+        }
+        const queryParameters = {};
+        if (requestParameters['output'] != null) {
+            queryParameters['output'] = requestParameters['output'];
+        }
+        if (requestParameters['include'] != null) {
+            queryParameters['include'] = requestParameters['include'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["unstructured-api-key"] = await this.configuration.apiKey("unstructured-api-key"); // ApiKeyAuth authentication
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v2/jobs/{jobId}`;
+        urlPath = urlPath.replace('{jobId}', encodeURIComponent(String(requestParameters['jobId'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Returns the job\'s status, and its content as soon as it is available, for a job started by either parse or extract. An extraction job\'s fields arrive in result.extracted_data. Send Accept text/event-stream for progress events as the job runs, ending in one result event whose data is this same JobResult.
+     * Get the status or result of a parse or extraction job
+     */
+    async jobsGetRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.jobsGetRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => JobResultFromJSON(jsonValue));
+    }
+    /**
+     * Returns the job\'s status, and its content as soon as it is available, for a job started by either parse or extract. An extraction job\'s fields arrive in result.extracted_data. Send Accept text/event-stream for progress events as the job runs, ending in one result event whose data is this same JobResult.
+     * Get the status or result of a parse or extraction job
+     */
+    async jobsGet(requestParameters, initOverrides) {
+        const response = await this.jobsGetRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for jobsList without sending the request
+     */
+    async jobsListRequestOpts(requestParameters) {
+        const queryParameters = {};
+        if (requestParameters['cursor'] != null) {
+            queryParameters['cursor'] = requestParameters['cursor'];
+        }
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+        if (requestParameters['status'] != null) {
+            queryParameters['status'] = requestParameters['status'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["unstructured-api-key"] = await this.configuration.apiKey("unstructured-api-key"); // ApiKeyAuth authentication
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v2/jobs`;
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Returns this caller\'s visible jobs, newest first. Tenant scope comes from the credential; the request has no tenant parameter.
+     * List parse and extraction jobs
+     */
+    async jobsListRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.jobsListRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => JobPageFromJSON(jsonValue));
+    }
+    /**
+     * Returns this caller\'s visible jobs, newest first. Tenant scope comes from the credential; the request has no tenant parameter.
+     * List parse and extraction jobs
+     */
+    async jobsList(requestParameters = {}, initOverrides) {
+        const response = await this.jobsListRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+}