@modernedi/sdk 0.1.0

package/dist/generated/apis/TransactionViewerApi.js

@@ -0,0 +1,733 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * ModernEDI TypeScript SDK, generated from the ModernEDI Integration API
+ * specification version 1.19.0 with OpenAPI Generator 7.24.0.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * Do not edit this generated file manually.
+ */
+import * as runtime from '../runtime.js';
+import { FilterableFunctionalAcknowledgmentStatus, } from '../models/FilterableFunctionalAcknowledgmentStatus.js';
+import { FilterableTransactionMappingStatus, } from '../models/FilterableTransactionMappingStatus.js';
+import { FilterableTransactionMdnStatus, } from '../models/FilterableTransactionMdnStatus.js';
+import { RelatedTransactionsResponseFromJSON, } from '../models/RelatedTransactionsResponse.js';
+import { TransactionDetailResponseFromJSON, } from '../models/TransactionDetailResponse.js';
+import { TransactionDocumentResponseFromJSON, } from '../models/TransactionDocumentResponse.js';
+import { TransactionDocumentsResponseFromJSON, } from '../models/TransactionDocumentsResponse.js';
+import { TransactionEventsResponseFromJSON, } from '../models/TransactionEventsResponse.js';
+import { TransactionListResponseFromJSON, } from '../models/TransactionListResponse.js';
+import { TransactionReplayRequestToJSON, } from '../models/TransactionReplayRequest.js';
+import { TransactionReplayResponseFromJSON, } from '../models/TransactionReplayResponse.js';
+import { TransactionWatchResponseFromJSON, } from '../models/TransactionWatchResponse.js';
+import { TransactionX12ValidationResponseFromJSON, } from '../models/TransactionX12ValidationResponse.js';
+const TRANSACTION_MAPPING_STATUS_FILTER_VALUES = new Set(Object.values(FilterableTransactionMappingStatus));
+const FUNCTIONAL_ACKNOWLEDGMENT_STATUS_FILTER_VALUES = new Set(Object.values(FilterableFunctionalAcknowledgmentStatus));
+const TRANSACTION_MDN_STATUS_FILTER_VALUES = new Set(Object.values(FilterableTransactionMdnStatus));
+function assertKnownTransactionFilterValues(parameterName, values, allowedValues) {
+    if (!Array.isArray(values)) {
+        throw new TypeError(`${parameterName} must be an array`);
+    }
+    const invalidValue = values.find((value) => !allowedValues.has(value));
+    if (invalidValue !== undefined) {
+        throw new TypeError(`${parameterName} contains unsupported value ${JSON.stringify(invalidValue)}; ` +
+            `expected one of ${[...allowedValues].join(', ')}`);
+    }
+}
+/**
+ *
+ */
+export class TransactionViewerApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getIntegrationTransaction without sending the request
+     */
+    async getIntegrationTransactionRequestOpts(requestParameters) {
+        if (requestParameters['messageId'] == null) {
+            throw new runtime.RequiredError('messageId', 'Required parameter "messageId" was null or undefined when calling getIntegrationTransaction().');
+        }
+        if (requestParameters['transactionKey'] == null) {
+            throw new runtime.RequiredError('transactionKey', 'Required parameter "transactionKey" was null or undefined when calling getIntegrationTransaction().');
+        }
+        const queryParameters = {};
+        if (requestParameters['environment'] != null) {
+            queryParameters['environment'] = requestParameters['environment'];
+        }
+        const headerParameters = {};
+        if (requestParameters['xRequestId'] != null) {
+            headerParameters['X-Request-Id'] = String(requestParameters['xRequestId']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("IntegrationApiKeyBearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // IntegrationApiKeyHeader authentication
+        }
+        let urlPath = `/v1/integration/transactions/{messageId}/{transactionKey}`;
+        urlPath = urlPath.replace('{messageId}', encodeURIComponent(String(requestParameters['messageId'])));
+        urlPath = urlPath.replace('{transactionKey}', encodeURIComponent(String(requestParameters['transactionKey'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Returns a metadata-first transaction aggregate: the summary, mapped output provenance and managed handoff state, normalized acknowledgment status, a document index, timeline events, compact linked-reply summaries, and the complete mapping-attempt history used to explain `needsAttention`. Document bodies are returned only by the individual document endpoint.
+     * Get transaction detail
+     */
+    async getIntegrationTransactionRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getIntegrationTransactionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TransactionDetailResponseFromJSON(jsonValue));
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Returns a metadata-first transaction aggregate: the summary, mapped output provenance and managed handoff state, normalized acknowledgment status, a document index, timeline events, compact linked-reply summaries, and the complete mapping-attempt history used to explain `needsAttention`. Document bodies are returned only by the individual document endpoint.
+     * Get transaction detail
+     */
+    async getIntegrationTransaction(requestParameters, initOverrides) {
+        const response = await this.getIntegrationTransactionRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for getIntegrationTransactionDocument without sending the request
+     */
+    async getIntegrationTransactionDocumentRequestOpts(requestParameters) {
+        if (requestParameters['messageId'] == null) {
+            throw new runtime.RequiredError('messageId', 'Required parameter "messageId" was null or undefined when calling getIntegrationTransactionDocument().');
+        }
+        if (requestParameters['transactionKey'] == null) {
+            throw new runtime.RequiredError('transactionKey', 'Required parameter "transactionKey" was null or undefined when calling getIntegrationTransactionDocument().');
+        }
+        if (requestParameters['documentId'] == null) {
+            throw new runtime.RequiredError('documentId', 'Required parameter "documentId" was null or undefined when calling getIntegrationTransactionDocument().');
+        }
+        const queryParameters = {};
+        if (requestParameters['environment'] != null) {
+            queryParameters['environment'] = requestParameters['environment'];
+        }
+        const headerParameters = {};
+        if (requestParameters['xRequestId'] != null) {
+            headerParameters['X-Request-Id'] = String(requestParameters['xRequestId']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("IntegrationApiKeyBearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // IntegrationApiKeyHeader authentication
+        }
+        let urlPath = `/v1/integration/transactions/{messageId}/{transactionKey}/documents/{documentId}`;
+        urlPath = urlPath.replace('{messageId}', encodeURIComponent(String(requestParameters['messageId'])));
+        urlPath = urlPath.replace('{transactionKey}', encodeURIComponent(String(requestParameters['transactionKey'])));
+        urlPath = urlPath.replace('{documentId}', encodeURIComponent(String(requestParameters['documentId'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Returns one complete retained artifact selected by the stable transaction-local `documentId` from the document list. A document id is not a mapped-output queue id and cannot be used to acknowledge delivery. The returned body is untrusted external content and must be rendered as untrusted external content: escape text, sanitize any supported markup, and sandbox richer previews instead of inserting it directly into a page.
+     * Get one transaction document
+     */
+    async getIntegrationTransactionDocumentRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getIntegrationTransactionDocumentRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TransactionDocumentResponseFromJSON(jsonValue));
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Returns one complete retained artifact selected by the stable transaction-local `documentId` from the document list. A document id is not a mapped-output queue id and cannot be used to acknowledge delivery. The returned body is untrusted external content and must be rendered as untrusted external content: escape text, sanitize any supported markup, and sandbox richer previews instead of inserting it directly into a page.
+     * Get one transaction document
+     */
+    async getIntegrationTransactionDocument(requestParameters, initOverrides) {
+        const response = await this.getIntegrationTransactionDocumentRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for getIntegrationTransactionDocuments without sending the request
+     */
+    async getIntegrationTransactionDocumentsRequestOpts(requestParameters) {
+        if (requestParameters['messageId'] == null) {
+            throw new runtime.RequiredError('messageId', 'Required parameter "messageId" was null or undefined when calling getIntegrationTransactionDocuments().');
+        }
+        if (requestParameters['transactionKey'] == null) {
+            throw new runtime.RequiredError('transactionKey', 'Required parameter "transactionKey" was null or undefined when calling getIntegrationTransactionDocuments().');
+        }
+        const queryParameters = {};
+        if (requestParameters['environment'] != null) {
+            queryParameters['environment'] = requestParameters['environment'];
+        }
+        const headerParameters = {};
+        if (requestParameters['xRequestId'] != null) {
+            headerParameters['X-Request-Id'] = String(requestParameters['xRequestId']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("IntegrationApiKeyBearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // IntegrationApiKeyHeader authentication
+        }
+        let urlPath = `/v1/integration/transactions/{messageId}/{transactionKey}/documents`;
+        urlPath = urlPath.replace('{messageId}', encodeURIComponent(String(requestParameters['messageId'])));
+        urlPath = urlPath.replace('{transactionKey}', encodeURIComponent(String(requestParameters['transactionKey'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Returns a lightweight metadata index for raw X12, mapped inbound outputs, MDN reports, acknowledgements, and HTTP responses recorded for the transaction. It never returns document bodies. Fetch one selected body from the individual document endpoint when an operator opens it.
+     * Get transaction documents
+     */
+    async getIntegrationTransactionDocumentsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getIntegrationTransactionDocumentsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TransactionDocumentsResponseFromJSON(jsonValue));
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Returns a lightweight metadata index for raw X12, mapped inbound outputs, MDN reports, acknowledgements, and HTTP responses recorded for the transaction. It never returns document bodies. Fetch one selected body from the individual document endpoint when an operator opens it.
+     * Get transaction documents
+     */
+    async getIntegrationTransactionDocuments(requestParameters, initOverrides) {
+        const response = await this.getIntegrationTransactionDocumentsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for getIntegrationTransactionEvents without sending the request
+     */
+    async getIntegrationTransactionEventsRequestOpts(requestParameters) {
+        if (requestParameters['messageId'] == null) {
+            throw new runtime.RequiredError('messageId', 'Required parameter "messageId" was null or undefined when calling getIntegrationTransactionEvents().');
+        }
+        if (requestParameters['transactionKey'] == null) {
+            throw new runtime.RequiredError('transactionKey', 'Required parameter "transactionKey" was null or undefined when calling getIntegrationTransactionEvents().');
+        }
+        const queryParameters = {};
+        if (requestParameters['environment'] != null) {
+            queryParameters['environment'] = requestParameters['environment'];
+        }
+        const headerParameters = {};
+        if (requestParameters['xRequestId'] != null) {
+            headerParameters['X-Request-Id'] = String(requestParameters['xRequestId']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("IntegrationApiKeyBearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // IntegrationApiKeyHeader authentication
+        }
+        let urlPath = `/v1/integration/transactions/{messageId}/{transactionKey}/events`;
+        urlPath = urlPath.replace('{messageId}', encodeURIComponent(String(requestParameters['messageId'])));
+        urlPath = urlPath.replace('{transactionKey}', encodeURIComponent(String(requestParameters['transactionKey'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Returns a normalized timeline for the transaction, including receipt or send events, mapping events, MDNs, acknowledgements, mapped-output availability/delivery/redelivery/attention/acknowledgment, and linked replies. These entries are derived from current persisted evidence; an output acknowledgment means acknowledged by your integration, not accepted by a downstream business system.
+     * Get transaction events
+     */
+    async getIntegrationTransactionEventsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getIntegrationTransactionEventsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TransactionEventsResponseFromJSON(jsonValue));
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Returns a normalized timeline for the transaction, including receipt or send events, mapping events, MDNs, acknowledgements, mapped-output availability/delivery/redelivery/attention/acknowledgment, and linked replies. These entries are derived from current persisted evidence; an output acknowledgment means acknowledged by your integration, not accepted by a downstream business system.
+     * Get transaction events
+     */
+    async getIntegrationTransactionEvents(requestParameters, initOverrides) {
+        const response = await this.getIntegrationTransactionEventsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for getRelatedIntegrationTransactions without sending the request
+     */
+    async getRelatedIntegrationTransactionsRequestOpts(requestParameters) {
+        if (requestParameters['messageId'] == null) {
+            throw new runtime.RequiredError('messageId', 'Required parameter "messageId" was null or undefined when calling getRelatedIntegrationTransactions().');
+        }
+        if (requestParameters['transactionKey'] == null) {
+            throw new runtime.RequiredError('transactionKey', 'Required parameter "transactionKey" was null or undefined when calling getRelatedIntegrationTransactions().');
+        }
+        const queryParameters = {};
+        if (requestParameters['environment'] != null) {
+            queryParameters['environment'] = requestParameters['environment'];
+        }
+        const headerParameters = {};
+        if (requestParameters['xRequestId'] != null) {
+            headerParameters['X-Request-Id'] = String(requestParameters['xRequestId']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("IntegrationApiKeyBearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // IntegrationApiKeyHeader authentication
+        }
+        let urlPath = `/v1/integration/transactions/{messageId}/{transactionKey}/related`;
+        urlPath = urlPath.replace('{messageId}', encodeURIComponent(String(requestParameters['messageId'])));
+        urlPath = urlPath.replace('{transactionKey}', encodeURIComponent(String(requestParameters['transactionKey'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Returns compact summaries of outbound reply transactions linked to an inbound transaction. Follow a summary\'s `messageId` and `transactionKey` to fetch its metadata-first detail or document index. New replies with `replyToTransactionKey` are included only under that exact transaction inside `replyToMessageId`; older message-level replies whose exact source key is absent remain visible under each transaction in the source message for backward compatibility. Use the returned linkage fields rather than inferring relationships from document type.
+     * Get linked reply transactions
+     */
+    async getRelatedIntegrationTransactionsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getRelatedIntegrationTransactionsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => RelatedTransactionsResponseFromJSON(jsonValue));
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Returns compact summaries of outbound reply transactions linked to an inbound transaction. Follow a summary\'s `messageId` and `transactionKey` to fetch its metadata-first detail or document index. New replies with `replyToTransactionKey` are included only under that exact transaction inside `replyToMessageId`; older message-level replies whose exact source key is absent remain visible under each transaction in the source message for backward compatibility. Use the returned linkage fields rather than inferring relationships from document type.
+     * Get linked reply transactions
+     */
+    async getRelatedIntegrationTransactions(requestParameters, initOverrides) {
+        const response = await this.getRelatedIntegrationTransactionsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for listIntegrationTransactions without sending the request
+     */
+    async listIntegrationTransactionsRequestOpts(requestParameters) {
+        const queryParameters = {};
+        if (requestParameters['environment'] != null) {
+            queryParameters['environment'] = requestParameters['environment'];
+        }
+        if (requestParameters['needsAttention'] != null) {
+            queryParameters['needsAttention'] = requestParameters['needsAttention'];
+        }
+        if (requestParameters['attentionReason'] != null) {
+            queryParameters['attentionReason'] = requestParameters['attentionReason'];
+        }
+        if (requestParameters['mappingStatus'] != null) {
+            assertKnownTransactionFilterValues('mappingStatus', requestParameters['mappingStatus'], TRANSACTION_MAPPING_STATUS_FILTER_VALUES);
+            queryParameters['mappingStatus'] = requestParameters['mappingStatus'];
+        }
+        if (requestParameters['functionalAckStatus'] != null) {
+            assertKnownTransactionFilterValues('functionalAckStatus', requestParameters['functionalAckStatus'], FUNCTIONAL_ACKNOWLEDGMENT_STATUS_FILTER_VALUES);
+            queryParameters['functionalAckStatus'] = requestParameters['functionalAckStatus'];
+        }
+        if (requestParameters['mdnStatus'] != null) {
+            assertKnownTransactionFilterValues('mdnStatus', requestParameters['mdnStatus'], TRANSACTION_MDN_STATUS_FILTER_VALUES);
+            queryParameters['mdnStatus'] = requestParameters['mdnStatus'];
+        }
+        if (requestParameters['startDate'] != null) {
+            queryParameters['startDate'] = requestParameters['startDate'];
+        }
+        if (requestParameters['endDate'] != null) {
+            queryParameters['endDate'] = requestParameters['endDate'];
+        }
+        if (requestParameters['cursor'] != null) {
+            queryParameters['cursor'] = requestParameters['cursor'];
+        }
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+        if (requestParameters['direction'] != null) {
+            queryParameters['direction'] = requestParameters['direction'];
+        }
+        if (requestParameters['partnerName'] != null) {
+            queryParameters['partnerName'] = requestParameters['partnerName'];
+        }
+        if (requestParameters['partnerId'] != null) {
+            queryParameters['partnerId'] = requestParameters['partnerId'];
+        }
+        if (requestParameters['transactionSet'] != null) {
+            queryParameters['transactionSet'] = requestParameters['transactionSet'];
+        }
+        if (requestParameters['businessKey'] != null) {
+            queryParameters['businessKey'] = requestParameters['businessKey'];
+        }
+        if (requestParameters['messageId'] != null) {
+            queryParameters['messageId'] = requestParameters['messageId'];
+        }
+        if (requestParameters['replyToMessageId'] != null) {
+            queryParameters['replyToMessageId'] = requestParameters['replyToMessageId'];
+        }
+        if (requestParameters['transactionControlNumber'] != null) {
+            queryParameters['transactionControlNumber'] = requestParameters['transactionControlNumber'];
+        }
+        if (requestParameters['functionalGroupControlNumber'] != null) {
+            queryParameters['functionalGroupControlNumber'] = requestParameters['functionalGroupControlNumber'];
+        }
+        const headerParameters = {};
+        if (requestParameters['xRequestId'] != null) {
+            headerParameters['X-Request-Id'] = String(requestParameters['xRequestId']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("IntegrationApiKeyBearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // IntegrationApiKeyHeader authentication
+        }
+        let urlPath = `/v1/integration/transactions`;
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Returns a pageable transaction history for custom transaction viewers, dashboards, and reconciliation workflows. Outbound replies include `replyToMessageId` so they can be shown underneath the inbound document they answer. Each row includes the stable `needsAttention` operator signal, machine-readable `attentionReasons`, and a compact `mappingStatus` so unattended integrations can route failures without fetching every transaction detail. `functionalAckStatus` and `mdnStatus` expose the same compact status values used by their exact list filters. The root `attentionSummary` is an environment-wide count and reconciliation-freshness signal; it is not restricted to the requested page or date window. Exact mapping, functional-acknowledgment, and MDN filters use that same asynchronous projection, so check `attentionSummary.freshness.complete` before treating an empty filtered page as proof that no matching transaction exists.
+     * List transactions
+     */
+    async listIntegrationTransactionsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.listIntegrationTransactionsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TransactionListResponseFromJSON(jsonValue));
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Returns a pageable transaction history for custom transaction viewers, dashboards, and reconciliation workflows. Outbound replies include `replyToMessageId` so they can be shown underneath the inbound document they answer. Each row includes the stable `needsAttention` operator signal, machine-readable `attentionReasons`, and a compact `mappingStatus` so unattended integrations can route failures without fetching every transaction detail. `functionalAckStatus` and `mdnStatus` expose the same compact status values used by their exact list filters. The root `attentionSummary` is an environment-wide count and reconciliation-freshness signal; it is not restricted to the requested page or date window. Exact mapping, functional-acknowledgment, and MDN filters use that same asynchronous projection, so check `attentionSummary.freshness.complete` before treating an empty filtered page as proof that no matching transaction exists.
+     * List transactions
+     */
+    async listIntegrationTransactions(requestParameters = {}, initOverrides) {
+        const response = await this.listIntegrationTransactionsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for replayIntegrationTransaction without sending the request
+     */
+    async replayIntegrationTransactionRequestOpts(requestParameters) {
+        if (requestParameters['messageId'] == null) {
+            throw new runtime.RequiredError('messageId', 'Required parameter "messageId" was null or undefined when calling replayIntegrationTransaction().');
+        }
+        if (requestParameters['transactionKey'] == null) {
+            throw new runtime.RequiredError('transactionKey', 'Required parameter "transactionKey" was null or undefined when calling replayIntegrationTransaction().');
+        }
+        if (requestParameters['idempotencyKey'] == null) {
+            throw new runtime.RequiredError('idempotencyKey', 'Required parameter "idempotencyKey" was null or undefined when calling replayIntegrationTransaction().');
+        }
+        if (requestParameters['transactionReplayRequest'] == null) {
+            throw new runtime.RequiredError('transactionReplayRequest', 'Required parameter "transactionReplayRequest" was null or undefined when calling replayIntegrationTransaction().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['xRequestId'] != null) {
+            headerParameters['X-Request-Id'] = String(requestParameters['xRequestId']);
+        }
+        if (requestParameters['idempotencyKey'] != null) {
+            headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("IntegrationApiKeyBearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // IntegrationApiKeyHeader authentication
+        }
+        let urlPath = `/v1/integration/transactions/{messageId}/{transactionKey}/replays`;
+        urlPath = urlPath.replace('{messageId}', encodeURIComponent(String(requestParameters['messageId'])));
+        urlPath = urlPath.replace('{transactionKey}', encodeURIComponent(String(requestParameters['transactionKey'])));
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: TransactionReplayRequestToJSON(requestParameters['transactionReplayRequest']),
+        };
+    }
+    /**
+     * **Required key scope:** `transactions:replay`.  Re-runs mapping for one tenant-visible inbound transaction with the currently published maps and returns the regenerated mapped outputs directly. Historical map revision replay is not part of the public API.  The only supported delivery is `response_only`. ModernEDI does not put regenerated outputs on the mapped-output queue, invoke mapped-output webhooks, or generate outbound acknowledgements. This endpoint is therefore suitable for inspection and controlled recovery without repeating downstream delivery side effects.  `Idempotency-Key` is required. Repeating the same key and request returns the stored successful replay with `Idempotency-Replayed: true` and does not invoke mapping again. Reusing the key for different replay input returns `409 idempotency_key_conflict`; retry while the same replay is still processing returns `409 idempotency_key_in_progress` with `retryable: true`.  The replay body is strict JSON: unknown fields are rejected, and `environment`, `mode`, `delivery`, and `reason` must be strings when present (`reason` may also be `null`). Type mismatches return `400 invalid_request` with the offending JSON pointer.
+     * Replay an inbound transaction without redelivery
+     */
+    async replayIntegrationTransactionRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.replayIntegrationTransactionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TransactionReplayResponseFromJSON(jsonValue));
+    }
+    /**
+     * **Required key scope:** `transactions:replay`.  Re-runs mapping for one tenant-visible inbound transaction with the currently published maps and returns the regenerated mapped outputs directly. Historical map revision replay is not part of the public API.  The only supported delivery is `response_only`. ModernEDI does not put regenerated outputs on the mapped-output queue, invoke mapped-output webhooks, or generate outbound acknowledgements. This endpoint is therefore suitable for inspection and controlled recovery without repeating downstream delivery side effects.  `Idempotency-Key` is required. Repeating the same key and request returns the stored successful replay with `Idempotency-Replayed: true` and does not invoke mapping again. Reusing the key for different replay input returns `409 idempotency_key_conflict`; retry while the same replay is still processing returns `409 idempotency_key_in_progress` with `retryable: true`.  The replay body is strict JSON: unknown fields are rejected, and `environment`, `mode`, `delivery`, and `reason` must be strings when present (`reason` may also be `null`). Type mismatches return `400 invalid_request` with the offending JSON pointer.
+     * Replay an inbound transaction without redelivery
+     */
+    async replayIntegrationTransaction(requestParameters, initOverrides) {
+        const response = await this.replayIntegrationTransactionRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for unwatchIntegrationTransaction without sending the request
+     */
+    async unwatchIntegrationTransactionRequestOpts(requestParameters) {
+        if (requestParameters['messageId'] == null) {
+            throw new runtime.RequiredError('messageId', 'Required parameter "messageId" was null or undefined when calling unwatchIntegrationTransaction().');
+        }
+        if (requestParameters['transactionKey'] == null) {
+            throw new runtime.RequiredError('transactionKey', 'Required parameter "transactionKey" was null or undefined when calling unwatchIntegrationTransaction().');
+        }
+        const queryParameters = {};
+        if (requestParameters['environment'] != null) {
+            queryParameters['environment'] = requestParameters['environment'];
+        }
+        const headerParameters = {};
+        if (requestParameters['xRequestId'] != null) {
+            headerParameters['X-Request-Id'] = String(requestParameters['xRequestId']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("IntegrationApiKeyBearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // IntegrationApiKeyHeader authentication
+        }
+        let urlPath = `/v1/integration/transactions/{messageId}/{transactionKey}/watch`;
+        urlPath = urlPath.replace('{messageId}', encodeURIComponent(String(requestParameters['messageId'])));
+        urlPath = urlPath.replace('{transactionKey}', encodeURIComponent(String(requestParameters['transactionKey'])));
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * **Required key scope:** `transactions:write`. Idempotently removes a tenant-visible transaction from the selected environment\'s operator watchlist. The response reports `onWatchlist: false` even when the transaction was already unwatched, so retrying after a network failure is safe. Workspace-wide attention counts and status-filter projections are asynchronous; use their `freshness` object when reconciling an immediately following list response.
+     * Stop watching a transaction
+     */
+    async unwatchIntegrationTransactionRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.unwatchIntegrationTransactionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TransactionWatchResponseFromJSON(jsonValue));
+    }
+    /**
+     * **Required key scope:** `transactions:write`. Idempotently removes a tenant-visible transaction from the selected environment\'s operator watchlist. The response reports `onWatchlist: false` even when the transaction was already unwatched, so retrying after a network failure is safe. Workspace-wide attention counts and status-filter projections are asynchronous; use their `freshness` object when reconciling an immediately following list response.
+     * Stop watching a transaction
+     */
+    async unwatchIntegrationTransaction(requestParameters, initOverrides) {
+        const response = await this.unwatchIntegrationTransactionRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for validateIntegrationTransactionX12 without sending the request
+     */
+    async validateIntegrationTransactionX12RequestOpts(requestParameters) {
+        if (requestParameters['messageId'] == null) {
+            throw new runtime.RequiredError('messageId', 'Required parameter "messageId" was null or undefined when calling validateIntegrationTransactionX12().');
+        }
+        if (requestParameters['transactionKey'] == null) {
+            throw new runtime.RequiredError('transactionKey', 'Required parameter "transactionKey" was null or undefined when calling validateIntegrationTransactionX12().');
+        }
+        const queryParameters = {};
+        if (requestParameters['environment'] != null) {
+            queryParameters['environment'] = requestParameters['environment'];
+        }
+        const headerParameters = {};
+        if (requestParameters['xRequestId'] != null) {
+            headerParameters['X-Request-Id'] = String(requestParameters['xRequestId']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("IntegrationApiKeyBearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // IntegrationApiKeyHeader authentication
+        }
+        let urlPath = `/v1/integration/transactions/{messageId}/{transactionKey}/x12/validation`;
+        urlPath = urlPath.replace('{messageId}', encodeURIComponent(String(requestParameters['messageId'])));
+        urlPath = urlPath.replace('{transactionKey}', encodeURIComponent(String(requestParameters['transactionKey'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Parses and validates the X12 content ModernEDI retained for this transaction and returns the same structured validation model as `POST /v1/x12/validate`. Invalid X12 is a successful analysis response with `validation.valid=false`, not an HTTP error. The retained X12 can be a complete interchange containing more than one transaction set; use the returned group and transaction indexes when displaying errors. This read-only endpoint lets transaction-viewer keys inspect stored content without granting message-send or transaction-replay authority. It does not rerun mappings, create mapped outputs, replay the transaction, or resend a document.
+     * Validate the X12 retained for a transaction
+     */
+    async validateIntegrationTransactionX12Raw(requestParameters, initOverrides) {
+        const requestOptions = await this.validateIntegrationTransactionX12RequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TransactionX12ValidationResponseFromJSON(jsonValue));
+    }
+    /**
+     * **Required key scope:** `transactions:read`. Parses and validates the X12 content ModernEDI retained for this transaction and returns the same structured validation model as `POST /v1/x12/validate`. Invalid X12 is a successful analysis response with `validation.valid=false`, not an HTTP error. The retained X12 can be a complete interchange containing more than one transaction set; use the returned group and transaction indexes when displaying errors. This read-only endpoint lets transaction-viewer keys inspect stored content without granting message-send or transaction-replay authority. It does not rerun mappings, create mapped outputs, replay the transaction, or resend a document.
+     * Validate the X12 retained for a transaction
+     */
+    async validateIntegrationTransactionX12(requestParameters, initOverrides) {
+        const response = await this.validateIntegrationTransactionX12Raw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for watchIntegrationTransaction without sending the request
+     */
+    async watchIntegrationTransactionRequestOpts(requestParameters) {
+        if (requestParameters['messageId'] == null) {
+            throw new runtime.RequiredError('messageId', 'Required parameter "messageId" was null or undefined when calling watchIntegrationTransaction().');
+        }
+        if (requestParameters['transactionKey'] == null) {
+            throw new runtime.RequiredError('transactionKey', 'Required parameter "transactionKey" was null or undefined when calling watchIntegrationTransaction().');
+        }
+        const queryParameters = {};
+        if (requestParameters['environment'] != null) {
+            queryParameters['environment'] = requestParameters['environment'];
+        }
+        const headerParameters = {};
+        if (requestParameters['xRequestId'] != null) {
+            headerParameters['X-Request-Id'] = String(requestParameters['xRequestId']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("IntegrationApiKeyBearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // IntegrationApiKeyHeader authentication
+        }
+        let urlPath = `/v1/integration/transactions/{messageId}/{transactionKey}/watch`;
+        urlPath = urlPath.replace('{messageId}', encodeURIComponent(String(requestParameters['messageId'])));
+        urlPath = urlPath.replace('{transactionKey}', encodeURIComponent(String(requestParameters['transactionKey'])));
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * **Required key scope:** `transactions:write`. Idempotently adds a tenant-visible transaction to the selected environment\'s operator watchlist. Public API watch entries do not expire and remain active until the DELETE operation removes them. The response reports the resulting state, so retrying the same request is safe. Workspace-wide attention counts and status-filter projections are asynchronous; use their `freshness` object when reconciling an immediately following list response.
+     * Watch a transaction
+     */
+    async watchIntegrationTransactionRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.watchIntegrationTransactionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TransactionWatchResponseFromJSON(jsonValue));
+    }
+    /**
+     * **Required key scope:** `transactions:write`. Idempotently adds a tenant-visible transaction to the selected environment\'s operator watchlist. Public API watch entries do not expire and remain active until the DELETE operation removes them. The response reports the resulting state, so retrying the same request is safe. Workspace-wide attention counts and status-filter projections are asynchronous; use their `freshness` object when reconciling an immediately following list response.
+     * Watch a transaction
+     */
+    async watchIntegrationTransaction(requestParameters, initOverrides) {
+        const response = await this.watchIntegrationTransactionRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+}
+/**
+ * @export
+ */
+export const GetIntegrationTransactionEnvironmentEnum = {
+    Production: 'production',
+    Test: 'test',
+    UnknownDefaultOpenApi: '11184809'
+};
+/**
+ * @export
+ */
+export const GetIntegrationTransactionDocumentEnvironmentEnum = {
+    Production: 'production',
+    Test: 'test',
+    UnknownDefaultOpenApi: '11184809'
+};
+/**
+ * @export
+ */
+export const GetIntegrationTransactionDocumentsEnvironmentEnum = {
+    Production: 'production',
+    Test: 'test',
+    UnknownDefaultOpenApi: '11184809'
+};
+/**
+ * @export
+ */
+export const GetIntegrationTransactionEventsEnvironmentEnum = {
+    Production: 'production',
+    Test: 'test',
+    UnknownDefaultOpenApi: '11184809'
+};
+/**
+ * @export
+ */
+export const GetRelatedIntegrationTransactionsEnvironmentEnum = {
+    Production: 'production',
+    Test: 'test',
+    UnknownDefaultOpenApi: '11184809'
+};
+/**
+ * @export
+ */
+export const ListIntegrationTransactionsEnvironmentEnum = {
+    Production: 'production',
+    Test: 'test',
+    UnknownDefaultOpenApi: '11184809'
+};
+/**
+ * @export
+ */
+export const ListIntegrationTransactionsDirectionEnum = {
+    Inbound: 'inbound',
+    Outbound: 'outbound',
+    UnknownDefaultOpenApi: '11184809'
+};
+/**
+ * @export
+ */
+export const UnwatchIntegrationTransactionEnvironmentEnum = {
+    Production: 'production',
+    Test: 'test',
+    UnknownDefaultOpenApi: '11184809'
+};
+/**
+ * @export
+ */
+export const ValidateIntegrationTransactionX12EnvironmentEnum = {
+    Production: 'production',
+    Test: 'test',
+    UnknownDefaultOpenApi: '11184809'
+};
+/**
+ * @export
+ */
+export const WatchIntegrationTransactionEnvironmentEnum = {
+    Production: 'production',
+    Test: 'test',
+    UnknownDefaultOpenApi: '11184809'
+};
+//# sourceMappingURL=TransactionViewerApi.js.map