nxus-qbd 0.7.2 → 1.0.0

package/dist/resources/base.js

@@ -5,14 +5,111 @@
  * restricted variants that expose only the operations supported by each
  * QuickBooks Desktop endpoint.
  */
-import { PaginationError } from '../helpers/pagination';
-const LIST_TIMEOUT_HINT_HEADER = 'X-Nxus-Timeout-Seconds';
+import { randomUUID } from "node:crypto";
+import { enableIdempotentCreateTimeoutRetry, } from "../transport.js";
+import { PaginationError } from "../helpers/pagination.js";
+import { NxusResponse } from "../helpers/response.js";
+const REQUEST_OPTION_KEYS = [
+    "connectionId",
+    "idempotencyKey",
+    "headers",
+    "timeout",
+    "serverTimeoutSeconds",
+    "maxRetries",
+    "verbose",
+    "fetchOptions",
+    "includeRawBody",
+];
+const REQUEST_OPTION_KEY_SET = new Set(REQUEST_OPTION_KEYS);
+const CURSOR_CLOSE_STRIPPED_HEADERS = new Set([
+    "x-connection-id",
+    "x-nxus-timeout-seconds",
+]);
+function findRequestOptionKeys(value, allowedKeys = []) {
+    const allowedKeySet = new Set(allowedKeys);
+    return REQUEST_OPTION_KEYS.filter((key) => !allowedKeySet.has(key) && value[key] !== undefined);
+}
+export function assertNoRequestOptionKeys(value, allowedKeys = []) {
+    if (!value) {
+        return;
+    }
+    const conflictingKeys = findRequestOptionKeys(value, allowedKeys);
+    if (conflictingKeys.length === 0) {
+        return;
+    }
+    throw new Error(`Request options must be passed in the second argument only; found transport keys in the first argument: ${conflictingKeys.join(", ")}`);
+}
+export function withDefaultMaxRetries(options, maxRetries) {
+    if (options?.maxRetries !== undefined) {
+        return options;
+    }
+    return { ...(options ?? {}), maxRetries };
+}
+/**
+ * Attach one stable idempotency key to a logical generic Create operation.
+ *
+ * A raw Idempotency-Key header remains supported for backwards compatibility,
+ * but the first-class option wins when both forms are supplied. The returned
+ * options object is constructed once before the transport retry loop, so all
+ * attempts reuse the same header.
+ */
+export function withCreateIdempotencyKey(options) {
+    const headers = { ...(options?.headers ?? {}) };
+    const headerEntry = Object.entries(headers).find(([name]) => name.toLowerCase() === "idempotency-key");
+    const idempotencyKey = options?.idempotencyKey ?? headerEntry?.[1] ?? randomUUID();
+    for (const name of Object.keys(headers)) {
+        if (name.toLowerCase() === "idempotency-key") {
+            delete headers[name];
+        }
+    }
+    return enableIdempotentCreateTimeoutRetry({
+        ...(options ?? {}),
+        idempotencyKey,
+        headers: {
+            ...headers,
+            "Idempotency-Key": idempotencyKey,
+        },
+    });
+}
+function splitListQueryAndOptions(query, options) {
+    if (!query) {
+        return {
+            query: {},
+            options,
+        };
+    }
+    assertNoRequestOptionKeys(query);
+    const nextQuery = { ...query };
+    const timeoutSeconds = nextQuery.timeoutSeconds;
+    delete nextQuery.timeoutSeconds;
+    let requestOptions = options;
+    if (requestOptions?.serverTimeoutSeconds === undefined &&
+        timeoutSeconds !== undefined) {
+        requestOptions = {
+            ...(options ?? {}),
+            serverTimeoutSeconds: timeoutSeconds,
+        };
+    }
+    return {
+        query: nextQuery,
+        options: requestOptions,
+    };
+}
+function extractCursorCloseOptions(options) {
+    const { connectionId: _connectionId, headers, serverTimeoutSeconds: _serverTimeoutSeconds, ...rest } = options ?? {};
+    const cursorCloseOptions = withDefaultMaxRetries(rest, 0);
+    const filteredHeaders = Object.fromEntries(Object.entries(headers ?? {}).filter(([name]) => !CURSOR_CLOSE_STRIPPED_HEADERS.has(name.toLowerCase())));
+    if (Object.keys(filteredHeaders).length > 0) {
+        cursorCloseOptions.headers = filteredHeaders;
+    }
+    return cursorCloseOptions;
+}
 // ---------------------------------------------------------------------------
 // Pagination helpers (adapted for transport)
 // ---------------------------------------------------------------------------
 function normalizePage(value) {
-    if (typeof value !== 'object' || value === null) {
-        throw new PaginationError('Expected a paginated response object with data, hasMore, and nextCursor fields.', { causeData: value });
+    if (typeof value !== "object" || value === null) {
+        throw new PaginationError("Expected a paginated response object with data, hasMore, and nextCursor fields.", { causeData: value });
     }
     const obj = value;
     const data = Array.isArray(obj.data) ? obj.data : [];
@@ -20,14 +117,14 @@ function normalizePage(value) {
         ...obj,
         data,
         hasMore: Boolean(obj.hasMore),
-        nextCursor: typeof obj.nextCursor === 'string' ? obj.nextCursor : null,
+        nextCursor: typeof obj.nextCursor === "string" ? obj.nextCursor : null,
     };
 }
 function wrapPage(page, fetchNextPage) {
     const hasNextPage = () => page.hasMore && Boolean(page.nextCursor);
     const getNextPage = async () => {
         if (!hasNextPage() || !page.nextCursor) {
-            throw new PaginationError('No additional pages are available.');
+            throw new PaginationError("No additional pages are available.");
         }
         return fetchNextPage(page.nextCursor);
     };
@@ -82,27 +179,51 @@ class TransportPaginationPromise {
         }
     }
 }
-// ---------------------------------------------------------------------------
-// Utility: extract RequestOptions from a params bag
-// ---------------------------------------------------------------------------
-function extractOptions(params) {
-    const { connectionId, headers, timeout, serverTimeoutSeconds, maxRetries, ...body } = params;
-    const options = {};
-    if (connectionId !== undefined)
-        options.connectionId = connectionId;
-    if (headers !== undefined)
-        options.headers = headers;
-    if (timeout !== undefined)
-        options.timeout = timeout;
-    if (serverTimeoutSeconds !== undefined)
-        options.serverTimeoutSeconds = serverTimeoutSeconds;
-    if (maxRetries !== undefined)
-        options.maxRetries = maxRetries;
-    return { body, options };
+/**
+ * Build the wrapped method set once, for every resource shape.
+ *
+ * These call the same transport paths as the plain methods — the plain ones
+ * are wrappers that discard the snapshot — so parsing, retries and error
+ * translation cannot drift between the two forms.
+ */
+function buildWithResponse(ctx) {
+    return {
+        async list(listQuery, options) {
+            const { query: requestQuery, options: requestOptions } = splitListQueryAndOptions(listQuery, options);
+            const wire = await ctx.transport.sendGet(ctx.basePath, requestQuery, requestOptions);
+            return NxusResponse.fromTransport(normalizePage(wire.body), wire);
+        },
+        async retrieve(id, options) {
+            const wire = await ctx.transport.sendGet(ctx.getSingularPath(id), undefined, options);
+            return NxusResponse.fromTransport(wire.body, wire);
+        },
+        async create(body, options) {
+            assertNoRequestOptionKeys(body);
+            const wire = await ctx.transport.sendPost(ctx.getCreatePath(), body, withCreateIdempotencyKey(options));
+            return NxusResponse.fromTransport(wire.body, wire);
+        },
+        async update(id, body, options) {
+            assertNoRequestOptionKeys(body);
+            const wire = await ctx.transport.sendPost(ctx.getSingularPath(id), body, options);
+            return NxusResponse.fromTransport(wire.body, wire);
+        },
+        async delete(id, options) {
+            const wire = await ctx.transport.sendDelete(ctx.getSingularPath(id), withDefaultMaxRetries(options, 0));
+            return NxusResponse.fromTransport(wire.body, wire);
+        },
+        async void(id, options) {
+            const wire = await ctx.transport.sendPost(`${ctx.getSingularPath(id)}/void`, undefined, withDefaultMaxRetries(options, 0));
+            return NxusResponse.fromTransport(wire.body, wire);
+        },
+    };
+}
+function pickWrappedResourceMethods(methods, keys) {
+    const picked = {};
+    for (const key of keys) {
+        picked[key] = methods[key];
+    }
+    return picked;
 }
-// ---------------------------------------------------------------------------
-// Resource<T> — full CRUD
-// ---------------------------------------------------------------------------
 export class Resource {
     transport;
     basePath;
@@ -119,7 +240,7 @@ export class Resource {
     getCreatePath() {
         if (this.createPath)
             return this.createPath;
-        return this.basePath.replace(/s$/, '');
+        return this.basePath.replace(/s$/, "");
     }
     /**
      * Build the singular path for a specific resource by ID.
@@ -129,48 +250,22 @@ export class Resource {
     getSingularPath(id) {
         return `${this.getCreatePath()}/${id}`;
     }
-    /**
-     * List resources with auto-pagination support.
-     *
-     * ```ts
-     * // Get the first page
-     * const page = await resource.list({ limit: 50, connectionId: "..." });
-     *
-     * // Auto-paginate
-     * for await (const item of resource.list({ limit: 50 })) { ... }
-     * ```
-     */
-    list(params) {
-        const { connectionId, headers, timeout, timeoutSeconds, serverTimeoutSeconds, maxRetries, ...query } = params ?? {};
-        const reqOptions = {};
-        if (connectionId !== undefined)
-            reqOptions.connectionId = connectionId;
-        if (timeout !== undefined)
-            reqOptions.timeout = timeout;
-        if (maxRetries !== undefined)
-            reqOptions.maxRetries = maxRetries;
-        const requestHeaders = headers
-            ? { ...headers }
-            : undefined;
-        const backendTimeoutSeconds = serverTimeoutSeconds ?? timeoutSeconds;
-        if (backendTimeoutSeconds !== undefined) {
-            const mergedHeaders = requestHeaders ?? {};
-            if (!(LIST_TIMEOUT_HINT_HEADER in mergedHeaders)) {
-                mergedHeaders[LIST_TIMEOUT_HINT_HEADER] = String(backendTimeoutSeconds);
-            }
-            reqOptions.headers = mergedHeaders;
-        }
-        else if (requestHeaders) {
-            reqOptions.headers = requestHeaders;
-        }
+    list(query, options) {
+        const { query: requestQuery, options: requestOptions } = splitListQueryAndOptions(query, options);
+        const cursorCloseOptions = extractCursorCloseOptions(requestOptions);
         const fetchPage = async (cursor) => {
-            const pageQuery = cursor ? { ...query, cursor } : { ...query };
-            const raw = await this.transport.get(this.basePath, pageQuery, reqOptions);
+            const pageQuery = cursor
+                ? { ...requestQuery, cursor }
+                : { ...requestQuery };
+            const raw = await this.transport.get(this.basePath, pageQuery, requestOptions);
             const page = normalizePage(raw);
             return wrapPage(page, (nextCursor) => fetchPage(nextCursor));
         };
         const closeCursor = async (cursor) => {
-            await this.transport.post(`/api/v1/cursors/${encodeURIComponent(cursor)}/close`);
+            // Cursor cleanup is transport-scoped, not connection-scoped. Reuse local
+            // transport controls and caller-provided headers, but intentionally drop
+            // connectionId and serverTimeoutSeconds.
+            await this.transport.post(`/api/v1/cursors/${encodeURIComponent(cursor)}/close`, undefined, cursorCloseOptions);
         };
         return new TransportPaginationPromise(fetchPage, closeCursor);
     }
@@ -184,40 +279,78 @@ export class Resource {
     async retrieve(id, options) {
         return this.transport.get(this.getSingularPath(id), undefined, options);
     }
-    /**
-     * Create a new resource. Fields are passed flat — `connectionId` and `headers`
-     * are extracted and sent as request options.
-     *
-     * ```ts
-     * const vendor = await resource.create({ name: "Acme", connectionId: "..." });
-     * ```
-     */
-    async create(params) {
-        const { body, options } = extractOptions(params);
-        return this.transport.post(this.getCreatePath(), body, options);
+    async create(body, options) {
+        assertNoRequestOptionKeys(body);
+        return this.transport.post(this.getCreatePath(), body, withCreateIdempotencyKey(options));
+    }
+    async update(id, body, options) {
+        assertNoRequestOptionKeys(body);
+        return this.transport.post(this.getSingularPath(id), body, options);
     }
     /**
-     * Update a resource. The Nxus API uses POST for updates.
+     * Delete a resource by ID.
      *
      * ```ts
-     * const vendor = await resource.update("80000001-1234567890", { name: "Updated", connectionId: "..." });
+     * await resource.delete("80000001-1234567890", { connectionId: "..." });
      * ```
      */
-    async update(id, params) {
-        const { body, options } = extractOptions(params);
-        return this.transport.post(this.getSingularPath(id), body, options);
+    async delete(id, options) {
+        return this.transport.delete(this.getSingularPath(id), withDefaultMaxRetries(options, 0));
     }
     /**
-     * Delete a resource by ID.
+     * Call any method on this resource and get status/headers back too.
      *
      * ```ts
-     * await resource.delete("80000001-1234567890", { connectionId: "..." });
+     * const check = await nxus.checks.create({ payeeId });
+     * // -> Check
+     *
+     * const wrapped = await nxus.checks.withResponse.create({ payeeId });
+     * // -> NxusResponse<Check>
+     * wrapped.data;      // the same Check
+     * wrapped.requestId; // 'req_abc123'
      * ```
      */
-    async delete(id, options) {
-        await this.transport.delete(this.getSingularPath(id), options);
+    get withResponse() {
+        return pickWrappedResourceMethods(buildWithResponse({
+            transport: this.transport,
+            basePath: this.basePath,
+            getCreatePath: () => this.getCreatePath(),
+            getSingularPath: (id) => this.getSingularPath(id),
+        }), ["list", "retrieve", "create", "update", "delete"]);
     }
 }
+/** Add the metadata-only count operation to a resource selected by the spec. */
+export function withCount(resource, transport, countPath) {
+    const count = async (query, options) => {
+        if (query && (query.limit !== undefined || query.cursor !== undefined)) {
+            throw new Error("count() does not accept limit or cursor parameters.");
+        }
+        const { query: requestQuery, options: requestOptions } = splitListQueryAndOptions(query, options);
+        return transport.get(countPath, requestQuery, requestOptions);
+    };
+    const originalWithResponse = resource
+        .withResponse;
+    Object.defineProperty(resource, "count", {
+        configurable: true,
+        value: count,
+    });
+    Object.defineProperty(resource, "withResponse", {
+        configurable: true,
+        get: () => ({
+            ...(originalWithResponse ?? {}),
+            count: async (query, options) => {
+                if (query &&
+                    (query.limit !== undefined || query.cursor !== undefined)) {
+                    throw new Error("count() does not accept limit or cursor parameters.");
+                }
+                const { query: requestQuery, options: requestOptions } = splitListQueryAndOptions(query, options);
+                const wire = await transport.sendGet(countPath, requestQuery, requestOptions);
+                return NxusResponse.fromTransport(wire.body, wire);
+            },
+        }),
+    });
+    return resource;
+}
 // ---------------------------------------------------------------------------
 // VoidableResource<T> — full CRUD plus void()
 // ---------------------------------------------------------------------------
@@ -235,7 +368,16 @@ export class VoidableResource extends Resource {
      * ```
      */
     async void(id, options) {
-        return this.transport.post(`${this.getSingularPath(id)}/void`, undefined, options);
+        return this.transport.post(`${this.getSingularPath(id)}/void`, undefined, withDefaultMaxRetries(options, 0));
+    }
+    /** Adds `void` to the inherited wrapped method set. */
+    get withResponse() {
+        return pickWrappedResourceMethods(buildWithResponse({
+            transport: this.transport,
+            basePath: this.basePath,
+            getCreatePath: () => this.getCreatePath(),
+            getSingularPath: (id) => this.getSingularPath(id),
+        }), ["list", "retrieve", "create", "update", "delete", "void"]);
     }
 }
 // ---------------------------------------------------------------------------
@@ -251,30 +393,108 @@ export class ReadOnlyResource {
         this.singularPath = singularPath;
     }
     getSingularPath(id) {
-        const path = this.singularPath ?? this.basePath.replace(/s$/, '');
+        const path = this.singularPath ?? this.basePath.replace(/s$/, "");
         return `${path}/${id}`;
     }
-    list(params) {
+    list(query, options) {
         // Delegate to a full Resource instance for the pagination logic
-        return new Resource(this.transport, this.basePath).list(params);
+        return new Resource(this.transport, this.basePath).list(query, options);
     }
     async retrieve(id, options) {
         return this.transport.get(this.getSingularPath(id), undefined, options);
     }
+    /** See {@link Resource.withResponse}. */
+    get withResponse() {
+        return pickWrappedResourceMethods(buildWithResponse({
+            transport: this.transport,
+            basePath: this.basePath,
+            getCreatePath: () => this.singularPath ?? this.basePath.replace(/s$/, ""),
+            getSingularPath: (id) => this.getSingularPath(id),
+        }), ["list", "retrieve"]);
+    }
 }
 // ---------------------------------------------------------------------------
 // Restricted variants
 // ---------------------------------------------------------------------------
 /** list + retrieve + create + delete (no update) */
-export class NoUpdateResource extends Resource {
-    update(_id, _params) {
-        throw new Error(`update() is not supported on ${this.basePath}`);
+export class NoUpdateResource {
+    transport;
+    basePath;
+    createPath;
+    constructor(transport, basePath, createPath) {
+        this.transport = transport;
+        this.basePath = basePath;
+        this.createPath = createPath;
+    }
+    getCreatePath() {
+        if (this.createPath)
+            return this.createPath;
+        return this.basePath.replace(/s$/, "");
+    }
+    getSingularPath(id) {
+        return `${this.getCreatePath()}/${id}`;
+    }
+    list(query, options) {
+        return new Resource(this.transport, this.basePath, this.createPath).list(query, options);
+    }
+    async retrieve(id, options) {
+        return this.transport.get(this.getSingularPath(id), undefined, options);
+    }
+    async create(body, options) {
+        assertNoRequestOptionKeys(body);
+        return this.transport.post(this.getCreatePath(), body, withCreateIdempotencyKey(options));
+    }
+    async delete(id, options) {
+        return this.transport.delete(this.getSingularPath(id), withDefaultMaxRetries(options, 0));
+    }
+    get withResponse() {
+        return pickWrappedResourceMethods(buildWithResponse({
+            transport: this.transport,
+            basePath: this.basePath,
+            getCreatePath: () => this.getCreatePath(),
+            getSingularPath: (id) => this.getSingularPath(id),
+        }), ["list", "retrieve", "create", "delete"]);
     }
 }
 /** list + retrieve + create + update (no delete) */
-export class NoDeleteResource extends Resource {
-    delete(_id, _options) {
-        throw new Error(`delete() is not supported on ${this.basePath}`);
+export class NoDeleteResource {
+    transport;
+    basePath;
+    createPath;
+    constructor(transport, basePath, createPath) {
+        this.transport = transport;
+        this.basePath = basePath;
+        this.createPath = createPath;
+    }
+    getCreatePath() {
+        if (this.createPath)
+            return this.createPath;
+        return this.basePath.replace(/s$/, "");
+    }
+    getSingularPath(id) {
+        return `${this.getCreatePath()}/${id}`;
+    }
+    list(query, options) {
+        return new Resource(this.transport, this.basePath, this.createPath).list(query, options);
+    }
+    async retrieve(id, options) {
+        return this.transport.get(this.getSingularPath(id), undefined, options);
+    }
+    async create(body, options) {
+        assertNoRequestOptionKeys(body);
+        return this.transport.post(this.getCreatePath(), body, withCreateIdempotencyKey(options));
+    }
+    async update(id, body, options) {
+        assertNoRequestOptionKeys(body);
+        return this.transport.post(this.getSingularPath(id), body, options);
+    }
+    get withResponse() {
+        return pickWrappedResourceMethods(buildWithResponse({
+            transport: this.transport,
+            basePath: this.basePath,
+            getCreatePath: () => this.getCreatePath(),
+            getSingularPath: (id) => this.getSingularPath(id),
+        }), ["list", "retrieve", "create", "update"]);
     }
 }
 /** list + retrieve + delete (no create, no update) */
@@ -286,16 +506,25 @@ export class ListRetrieveDeleteResource {
         this.basePath = basePath;
     }
     getSingularPath(id) {
-        return `${this.basePath.replace(/s$/, '')}/${id}`;
+        return `${this.basePath.replace(/s$/, "")}/${id}`;
     }
-    list(params) {
-        return new Resource(this.transport, this.basePath).list(params);
+    list(query, options) {
+        return new Resource(this.transport, this.basePath).list(query, options);
     }
     async retrieve(id, options) {
         return this.transport.get(this.getSingularPath(id), undefined, options);
     }
     async delete(id, options) {
-        await this.transport.delete(this.getSingularPath(id), options);
+        return this.transport.delete(this.getSingularPath(id), withDefaultMaxRetries(options, 0));
+    }
+    /** See {@link Resource.withResponse}. */
+    get withResponse() {
+        return pickWrappedResourceMethods(buildWithResponse({
+            transport: this.transport,
+            basePath: this.basePath,
+            getCreatePath: () => this.basePath.replace(/s$/, ""),
+            getSingularPath: (id) => this.getSingularPath(id),
+        }), ["list", "retrieve", "delete"]);
     }
 }
 /** list + delete (no retrieve, create, or update) */
@@ -309,14 +538,43 @@ export class ListDeleteResource {
         this.singularPath = singularPath;
     }
     getSingularPath(id) {
-        const path = this.singularPath ?? this.basePath.replace(/s$/, '');
+        const path = this.singularPath ?? this.basePath.replace(/s$/, "");
         return `${path}/${id}`;
     }
-    list(params) {
-        return new Resource(this.transport, this.basePath).list(params);
+    list(query, options) {
+        return new Resource(this.transport, this.basePath).list(query, options);
     }
     async delete(id, options) {
-        await this.transport.delete(this.getSingularPath(id), options);
+        return this.transport.delete(this.getSingularPath(id), withDefaultMaxRetries(options, 0));
+    }
+    /** See {@link Resource.withResponse}. */
+    get withResponse() {
+        return pickWrappedResourceMethods(buildWithResponse({
+            transport: this.transport,
+            basePath: this.basePath,
+            getCreatePath: () => this.singularPath ?? this.basePath.replace(/s$/, ""),
+            getSingularPath: (id) => this.getSingularPath(id),
+        }), ["list", "delete"]);
+    }
+}
+/** list only (no retrieve, create, update, or delete) */
+export class ListOnlyResource {
+    transport;
+    basePath;
+    constructor(transport, basePath) {
+        this.transport = transport;
+        this.basePath = basePath;
+    }
+    list(query, options) {
+        return new Resource(this.transport, this.basePath).list(query, options);
+    }
+    get withResponse() {
+        return pickWrappedResourceMethods(buildWithResponse({
+            transport: this.transport,
+            basePath: this.basePath,
+            getCreatePath: () => this.basePath,
+            getSingularPath: () => this.basePath,
+        }), ["list"]);
     }
 }
 /** list + retrieve + create (no update, no delete) */
@@ -332,31 +590,29 @@ export class ListRetrieveCreateResource {
     getCreatePath() {
         if (this.createPath)
             return this.createPath;
-        return this.basePath.replace(/s$/, '');
+        return this.basePath.replace(/s$/, "");
     }
     getSingularPath(id) {
         return `${this.getCreatePath()}/${id}`;
     }
-    list(params) {
-        return new Resource(this.transport, this.basePath).list(params);
+    list(query, options) {
+        return new Resource(this.transport, this.basePath).list(query, options);
     }
     async retrieve(id, options) {
         return this.transport.get(this.getSingularPath(id), undefined, options);
     }
-    async create(params) {
-        const { connectionId, headers, timeout, serverTimeoutSeconds, maxRetries, ...body } = params;
-        const options = {};
-        if (connectionId)
-            options.connectionId = connectionId;
-        if (headers)
-            options.headers = headers;
-        if (timeout)
-            options.timeout = timeout;
-        if (serverTimeoutSeconds)
-            options.serverTimeoutSeconds = serverTimeoutSeconds;
-        if (maxRetries !== undefined)
-            options.maxRetries = maxRetries;
-        return this.transport.post(this.getCreatePath(), body, options);
+    async create(body, options) {
+        assertNoRequestOptionKeys(body);
+        return this.transport.post(this.getCreatePath(), body, withCreateIdempotencyKey(options));
+    }
+    /** See {@link Resource.withResponse}. */
+    get withResponse() {
+        return pickWrappedResourceMethods(buildWithResponse({
+            transport: this.transport,
+            basePath: this.basePath,
+            getCreatePath: () => this.getCreatePath(),
+            getSingularPath: (id) => this.getSingularPath(id),
+        }), ["list", "retrieve", "create"]);
     }
 }
 /** list + retrieve + create + delete (no update) — same as NoUpdateResource but cleaner */
@@ -372,34 +628,46 @@ export class CrudNoUpdateResource {
     getCreatePath() {
         if (this.createPath)
             return this.createPath;
-        return this.basePath.replace(/s$/, '');
+        return this.basePath.replace(/s$/, "");
     }
     getSingularPath(id) {
         return `${this.getCreatePath()}/${id}`;
     }
-    list(params) {
-        return new Resource(this.transport, this.basePath).list(params);
+    list(query, options) {
+        return new Resource(this.transport, this.basePath).list(query, options);
     }
     async retrieve(id, options) {
         return this.transport.get(this.getSingularPath(id), undefined, options);
     }
-    async create(params) {
-        const { connectionId, headers, timeout, serverTimeoutSeconds, maxRetries, ...body } = params;
-        const options = {};
-        if (connectionId)
-            options.connectionId = connectionId;
-        if (headers)
-            options.headers = headers;
-        if (timeout)
-            options.timeout = timeout;
-        if (serverTimeoutSeconds)
-            options.serverTimeoutSeconds = serverTimeoutSeconds;
-        if (maxRetries !== undefined)
-            options.maxRetries = maxRetries;
-        return this.transport.post(this.getCreatePath(), body, options);
+    async create(body, options) {
+        assertNoRequestOptionKeys(body);
+        return this.transport.post(this.getCreatePath(), body, withCreateIdempotencyKey(options));
     }
     async delete(id, options) {
-        await this.transport.delete(this.getSingularPath(id), options);
+        return this.transport.delete(this.getSingularPath(id), withDefaultMaxRetries(options, 0));
+    }
+    /** See {@link Resource.withResponse}. */
+    get withResponse() {
+        return pickWrappedResourceMethods(buildWithResponse({
+            transport: this.transport,
+            basePath: this.basePath,
+            getCreatePath: () => this.getCreatePath(),
+            getSingularPath: (id) => this.getSingularPath(id),
+        }), ["list", "retrieve", "create", "delete"]);
+    }
+}
+/** list + retrieve + create + delete + void (no update) */
+export class VoidableNoUpdateResource extends CrudNoUpdateResource {
+    async void(id, options) {
+        return this.transport.post(`${this.getSingularPath(id)}/void`, undefined, withDefaultMaxRetries(options, 0));
+    }
+    get withResponse() {
+        return pickWrappedResourceMethods(buildWithResponse({
+            transport: this.transport,
+            basePath: this.basePath,
+            getCreatePath: () => this.getCreatePath(),
+            getSingularPath: (id) => this.getSingularPath(id),
+        }), ["list", "retrieve", "create", "delete", "void"]);
     }
 }
 /** create-only (e.g. Special Items) */
@@ -410,20 +678,18 @@ export class CreateOnlyResource {
         this.transport = transport;
         this.createPath = createPath;
     }
-    async create(params) {
-        const { connectionId, headers, timeout, serverTimeoutSeconds, maxRetries, ...body } = params;
-        const options = {};
-        if (connectionId)
-            options.connectionId = connectionId;
-        if (headers)
-            options.headers = headers;
-        if (timeout)
-            options.timeout = timeout;
-        if (serverTimeoutSeconds)
-            options.serverTimeoutSeconds = serverTimeoutSeconds;
-        if (maxRetries !== undefined)
-            options.maxRetries = maxRetries;
-        return this.transport.post(this.createPath, body, options);
+    async create(body, options) {
+        assertNoRequestOptionKeys(body);
+        return this.transport.post(this.createPath, body, withCreateIdempotencyKey(options));
+    }
+    /** See {@link Resource.withResponse}. */
+    get withResponse() {
+        return pickWrappedResourceMethods(buildWithResponse({
+            transport: this.transport,
+            basePath: this.createPath,
+            getCreatePath: () => this.createPath,
+            getSingularPath: () => this.createPath,
+        }), ["create"]);
     }
 }
 //# sourceMappingURL=base.js.map