merchi_sdk_ts 1.9.0 → 1.9.1

package/dist/entities/domain.js

@@ -49,6 +49,57 @@ var Domain = /** @class */ (function (_super) {
             }
             return _this.activeTheme;
         };
+        _this.getDomainId = function () {
+            if (_this.id === undefined || _this.id === null) {
+                throw new Error('id is undefined, did you forget to set it?');
+            }
+            return _this.id;
+        };
+        _this.storefrontV2DomainResource = function (suffix) {
+            if (suffix === void 0) { suffix = ''; }
+            return "/domains/".concat(_this.getDomainId(), "/storefront_v2/").concat(suffix);
+        };
+        _this.storefrontV2Request = function (resource, method, payload) {
+            var fetchOptions = {
+                method: method,
+                query: [['skip_rights', 'y']]
+            };
+            if (payload !== undefined) {
+                fetchOptions.body = JSON.stringify(payload);
+                fetchOptions.headers = { 'Content-Type': 'application/json' };
+            }
+            return _this.merchi.authenticatedFetch(resource, fetchOptions);
+        };
+        _this.getStorefrontV2 = function () {
+            return _this.storefrontV2Request(_this.storefrontV2DomainResource(), 'GET');
+        };
+        _this.provisionStorefrontV2 = function (payload) {
+            return _this.storefrontV2Request(_this.storefrontV2DomainResource('provision/'), 'POST', payload);
+        };
+        _this.createStorefrontChangeRequest = function (payload) {
+            return _this.storefrontV2Request(_this.storefrontV2DomainResource('requests/'), 'POST', payload);
+        };
+        _this.getStorefrontChangeRequest = function (requestId) {
+            return _this.storefrontV2Request("/storefront_change_requests/".concat(String(requestId), "/"), 'GET');
+        };
+        _this.runStorefrontChangeRequest = function (requestId, payload) {
+            return _this.storefrontV2Request("/storefront_change_requests/".concat(String(requestId), "/run/"), 'POST', payload);
+        };
+        _this.approveStorefrontChangeRequest = function (requestId, payload) {
+            return _this.storefrontV2Request("/storefront_change_requests/".concat(String(requestId), "/approve/"), 'POST', payload);
+        };
+        _this.rejectStorefrontChangeRequest = function (requestId, payload) {
+            return _this.storefrontV2Request("/storefront_change_requests/".concat(String(requestId), "/reject/"), 'POST', payload);
+        };
+        _this.getStorefrontV2Deployments = function () {
+            return _this.storefrontV2Request(_this.storefrontV2DomainResource('deployments/'), 'GET');
+        };
+        _this.getStorefrontV2DeploymentLogs = function (deploymentId) {
+            return _this.storefrontV2Request(_this.storefrontV2DomainResource("deployments/".concat(String(deploymentId), "/logs/")), 'GET');
+        };
+        _this.rollbackStorefrontV2 = function (payload) {
+            return _this.storefrontV2Request(_this.storefrontV2DomainResource('rollback/'), 'POST', payload);
+        };
         return _this;
     }
     Domain.resourceName = 'domains';

package/dist/entities/domain.test.js

@@ -66,3 +66,129 @@ test('fail to delete non-existant domain', function () {
     expect(fetch.mock.calls[0][1].method).toBe('DELETE');
     return invocation.catch(function (e) { return expect(e.statusCode).toEqual(404); });
 });
+test('can get storefront v2 config', function () {
+    var merchi = new Merchi();
+    var domain = new merchi.Domain();
+    domain.id = 42;
+    var fetch = mockFetch(true, {}, 200);
+    domain.getStorefrontV2();
+    var fetchUrl = fetch.mock.calls[0][0];
+    var query = fetch.mock.calls[0][1].query;
+    expect(fetch.mock.calls[0][1].method).toBe('GET');
+    expect(fetchUrl).toContain('/domains/42/storefront_v2/');
+    expect(query).toContainEqual(['skip_rights', 'y']);
+});
+test('can provision storefront v2', function () {
+    var merchi = new Merchi();
+    var domain = new merchi.Domain();
+    domain.id = 42;
+    var fetch = mockFetch(true, {}, 200);
+    domain.provisionStorefrontV2({ force: true });
+    var fetchUrl = fetch.mock.calls[0][0];
+    var body = JSON.parse(fetch.mock.calls[0][1].body);
+    expect(fetch.mock.calls[0][1].method).toBe('POST');
+    expect(fetchUrl).toContain('/domains/42/storefront_v2/provision/');
+    expect(body).toEqual({ force: true });
+});
+test('can create storefront v2 change request', function () {
+    var merchi = new Merchi();
+    var domain = new merchi.Domain();
+    domain.id = 42;
+    var fetch = mockFetch(true, {}, 200);
+    domain.createStorefrontChangeRequest({ prompt: 'update hero' });
+    var fetchUrl = fetch.mock.calls[0][0];
+    var body = JSON.parse(fetch.mock.calls[0][1].body);
+    expect(fetch.mock.calls[0][1].method).toBe('POST');
+    expect(fetchUrl).toContain('/domains/42/storefront_v2/requests/');
+    expect(body).toEqual({ prompt: 'update hero' });
+});
+test('can get storefront v2 change request by id', function () {
+    var merchi = new Merchi();
+    var domain = new merchi.Domain();
+    var fetch = mockFetch(true, {}, 200);
+    domain.getStorefrontChangeRequest(9);
+    var fetchUrl = fetch.mock.calls[0][0];
+    expect(fetch.mock.calls[0][1].method).toBe('GET');
+    expect(fetchUrl).toContain('/storefront_change_requests/9/');
+});
+test('can run storefront v2 change request', function () {
+    var merchi = new Merchi();
+    var domain = new merchi.Domain();
+    var fetch = mockFetch(true, {}, 200);
+    domain.runStorefrontChangeRequest(9, {
+        status: 'running',
+        pullRequestNumber: 42,
+        checksSummary: {
+            overall: 'passing',
+            counts: { total: 4, passed: 4, failed: 0, pending: 0, neutral: 0 },
+        },
+        checksUpdatedAt: '2026-05-15T00:00:00Z',
+    });
+    var fetchUrl = fetch.mock.calls[0][0];
+    var body = JSON.parse(fetch.mock.calls[0][1].body);
+    expect(fetch.mock.calls[0][1].method).toBe('POST');
+    expect(fetchUrl).toContain('/storefront_change_requests/9/run/');
+    expect(body).toEqual({
+        status: 'running',
+        pullRequestNumber: 42,
+        checksSummary: {
+            overall: 'passing',
+            counts: { total: 4, passed: 4, failed: 0, pending: 0, neutral: 0 },
+        },
+        checksUpdatedAt: '2026-05-15T00:00:00Z',
+    });
+});
+test('can approve storefront v2 change request', function () {
+    var merchi = new Merchi();
+    var domain = new merchi.Domain();
+    var fetch = mockFetch(true, {}, 200);
+    domain.approveStorefrontChangeRequest(9, { comment: 'looks good' });
+    var fetchUrl = fetch.mock.calls[0][0];
+    var body = JSON.parse(fetch.mock.calls[0][1].body);
+    expect(fetch.mock.calls[0][1].method).toBe('POST');
+    expect(fetchUrl).toContain('/storefront_change_requests/9/approve/');
+    expect(body).toEqual({ comment: 'looks good' });
+});
+test('can reject storefront v2 change request', function () {
+    var merchi = new Merchi();
+    var domain = new merchi.Domain();
+    var fetch = mockFetch(true, {}, 200);
+    domain.rejectStorefrontChangeRequest(9, { reason: 'needs edits' });
+    var fetchUrl = fetch.mock.calls[0][0];
+    var body = JSON.parse(fetch.mock.calls[0][1].body);
+    expect(fetch.mock.calls[0][1].method).toBe('POST');
+    expect(fetchUrl).toContain('/storefront_change_requests/9/reject/');
+    expect(body).toEqual({ reason: 'needs edits' });
+});
+test('can get storefront v2 deployments', function () {
+    var merchi = new Merchi();
+    var domain = new merchi.Domain();
+    domain.id = 42;
+    var fetch = mockFetch(true, {}, 200);
+    domain.getStorefrontV2Deployments();
+    var fetchUrl = fetch.mock.calls[0][0];
+    expect(fetch.mock.calls[0][1].method).toBe('GET');
+    expect(fetchUrl).toContain('/domains/42/storefront_v2/deployments/');
+});
+test('can get storefront v2 deployment logs', function () {
+    var merchi = new Merchi();
+    var domain = new merchi.Domain();
+    domain.id = 42;
+    var fetch = mockFetch(true, {}, 200);
+    domain.getStorefrontV2DeploymentLogs('dep_123');
+    var fetchUrl = fetch.mock.calls[0][0];
+    expect(fetch.mock.calls[0][1].method).toBe('GET');
+    expect(fetchUrl).toContain('/domains/42/storefront_v2/deployments/dep_123/logs/');
+});
+test('can rollback storefront v2 deployment', function () {
+    var merchi = new Merchi();
+    var domain = new merchi.Domain();
+    domain.id = 42;
+    var fetch = mockFetch(true, {}, 200);
+    domain.rollbackStorefrontV2({ deploymentId: 'dep_123' });
+    var fetchUrl = fetch.mock.calls[0][0];
+    var body = JSON.parse(fetch.mock.calls[0][1].body);
+    expect(fetch.mock.calls[0][1].method).toBe('POST');
+    expect(fetchUrl).toContain('/domains/42/storefront_v2/rollback/');
+    expect(body).toEqual({ deploymentId: 'dep_123' });
+});

package/dist/entities/notification.test.js

@@ -19,33 +19,3 @@ test('can list notifications with notificationSender filter', function () {
         expect(query).toContainEqual(['notification_sender', '123']);
     });
 });
-test('list forwards skipCount=true as skip_count query param', function () {
-    var merchi = new Merchi();
-    var fetch = mockFetch(true, {
-        'notifications': [],
-        // backend returns ``available: null`` when skip_count was honoured
-        'available': null,
-        'count': 0
-    }, 200);
-    var options = { skipCount: true };
-    return merchi.Notification.list(options).then(function (response) {
-        var query = fetch.mock.calls[0][1]['query'];
-        expect(query).toContainEqual(['skip_count', 'true']);
-        // ``available`` must round-trip as ``null``; the typed metadata
-        // is now ``number | null``, so consumers can detect the absence.
-        expect(response.metadata.available).toBeNull();
-    });
-});
-test('list omits skip_count when skipCount is not set', function () {
-    var merchi = new Merchi();
-    var fetch = mockFetch(true, {
-        'notifications': [],
-        'available': 0,
-        'count': 0
-    }, 200);
-    return merchi.Notification.list({}).then(function () {
-        var query = fetch.mock.calls[0][1]['query'];
-        var skipCountEntries = query.filter(function (entry) { return entry[0] === 'skip_count'; });
-        expect(skipCountEntries).toEqual([]);
-    });
-});

package/dist/entity.js

@@ -614,14 +614,6 @@ var Entity = /** @class */ (function () {
             if (options.limit !== undefined) {
                 fetchOptions.query.push(['limit', options.limit.toString()]);
             }
-            if (options.skipCount !== undefined) {
-                // Snake-case is the canonical form on the server; the API
-                // also accepts ``skipCount`` via its camelCase alias, but
-                // matching the wire shape of the other ``*_only`` /
-                // ``*_filter`` flags keeps logs and traffic captures
-                // consistent.
-                fetchOptions.query.push(['skip_count', options.skipCount.toString()]);
-            }
             if (options.q !== undefined) {
                 fetchOptions.query.push(['q', options.q]);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "merchi_sdk_ts",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "main": "dist/index.js",
   "type": "module",
   "repository": "git@github.com:merchisdk/merchi_sdk_ts.git",

package/src/entities/domain.test.ts

@@ -77,3 +77,139 @@ test('fail to delete non-existant domain', () => {
   expect(fetch.mock.calls[0][1].method).toBe('DELETE');
   return invocation.catch(e => expect(e.statusCode).toEqual(404));
 });
+
+test('can get storefront v2 config', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  domain.id = 42;
+  const fetch = mockFetch(true, {}, 200);
+  domain.getStorefrontV2();
+  const fetchUrl = fetch.mock.calls[0][0];
+  const query = fetch.mock.calls[0][1].query;
+  expect(fetch.mock.calls[0][1].method).toBe('GET');
+  expect(fetchUrl).toContain('/domains/42/storefront_v2/');
+  expect(query).toContainEqual(['skip_rights', 'y']);
+});
+
+test('can provision storefront v2', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  domain.id = 42;
+  const fetch = mockFetch(true, {}, 200);
+  domain.provisionStorefrontV2({force: true});
+  const fetchUrl = fetch.mock.calls[0][0];
+  const body = JSON.parse(fetch.mock.calls[0][1].body as string);
+  expect(fetch.mock.calls[0][1].method).toBe('POST');
+  expect(fetchUrl).toContain('/domains/42/storefront_v2/provision/');
+  expect(body).toEqual({force: true});
+});
+
+test('can create storefront v2 change request', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  domain.id = 42;
+  const fetch = mockFetch(true, {}, 200);
+  domain.createStorefrontChangeRequest({prompt: 'update hero'});
+  const fetchUrl = fetch.mock.calls[0][0];
+  const body = JSON.parse(fetch.mock.calls[0][1].body as string);
+  expect(fetch.mock.calls[0][1].method).toBe('POST');
+  expect(fetchUrl).toContain('/domains/42/storefront_v2/requests/');
+  expect(body).toEqual({prompt: 'update hero'});
+});
+
+test('can get storefront v2 change request by id', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  const fetch = mockFetch(true, {}, 200);
+  domain.getStorefrontChangeRequest(9);
+  const fetchUrl = fetch.mock.calls[0][0];
+  expect(fetch.mock.calls[0][1].method).toBe('GET');
+  expect(fetchUrl).toContain('/storefront_change_requests/9/');
+});
+
+test('can run storefront v2 change request', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  const fetch = mockFetch(true, {}, 200);
+  domain.runStorefrontChangeRequest(9, {
+    status: 'running',
+    pullRequestNumber: 42,
+    checksSummary: {
+      overall: 'passing',
+      counts: {total: 4, passed: 4, failed: 0, pending: 0, neutral: 0},
+    },
+    checksUpdatedAt: '2026-05-15T00:00:00Z',
+  });
+  const fetchUrl = fetch.mock.calls[0][0];
+  const body = JSON.parse(fetch.mock.calls[0][1].body as string);
+  expect(fetch.mock.calls[0][1].method).toBe('POST');
+  expect(fetchUrl).toContain('/storefront_change_requests/9/run/');
+  expect(body).toEqual({
+    status: 'running',
+    pullRequestNumber: 42,
+    checksSummary: {
+      overall: 'passing',
+      counts: {total: 4, passed: 4, failed: 0, pending: 0, neutral: 0},
+    },
+    checksUpdatedAt: '2026-05-15T00:00:00Z',
+  });
+});
+
+test('can approve storefront v2 change request', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  const fetch = mockFetch(true, {}, 200);
+  domain.approveStorefrontChangeRequest(9, {comment: 'looks good'});
+  const fetchUrl = fetch.mock.calls[0][0];
+  const body = JSON.parse(fetch.mock.calls[0][1].body as string);
+  expect(fetch.mock.calls[0][1].method).toBe('POST');
+  expect(fetchUrl).toContain('/storefront_change_requests/9/approve/');
+  expect(body).toEqual({comment: 'looks good'});
+});
+
+test('can reject storefront v2 change request', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  const fetch = mockFetch(true, {}, 200);
+  domain.rejectStorefrontChangeRequest(9, {reason: 'needs edits'});
+  const fetchUrl = fetch.mock.calls[0][0];
+  const body = JSON.parse(fetch.mock.calls[0][1].body as string);
+  expect(fetch.mock.calls[0][1].method).toBe('POST');
+  expect(fetchUrl).toContain('/storefront_change_requests/9/reject/');
+  expect(body).toEqual({reason: 'needs edits'});
+});
+
+test('can get storefront v2 deployments', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  domain.id = 42;
+  const fetch = mockFetch(true, {}, 200);
+  domain.getStorefrontV2Deployments();
+  const fetchUrl = fetch.mock.calls[0][0];
+  expect(fetch.mock.calls[0][1].method).toBe('GET');
+  expect(fetchUrl).toContain('/domains/42/storefront_v2/deployments/');
+});
+
+test('can get storefront v2 deployment logs', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  domain.id = 42;
+  const fetch = mockFetch(true, {}, 200);
+  domain.getStorefrontV2DeploymentLogs('dep_123');
+  const fetchUrl = fetch.mock.calls[0][0];
+  expect(fetch.mock.calls[0][1].method).toBe('GET');
+  expect(fetchUrl).toContain('/domains/42/storefront_v2/deployments/dep_123/logs/');
+});
+
+test('can rollback storefront v2 deployment', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  domain.id = 42;
+  const fetch = mockFetch(true, {}, 200);
+  domain.rollbackStorefrontV2({deploymentId: 'dep_123'});
+  const fetchUrl = fetch.mock.calls[0][0];
+  const body = JSON.parse(fetch.mock.calls[0][1].body as string);
+  expect(fetch.mock.calls[0][1].method).toBe('POST');
+  expect(fetchUrl).toContain('/domains/42/storefront_v2/rollback/');
+  expect(body).toEqual({deploymentId: 'dep_123'});
+});

package/src/entities/domain.ts

@@ -21,6 +21,43 @@ import { DomainChatSettings } from './domain_chat_settings.js';
 import { Theme } from './theme.js';
 import { DomainType } from '../constants/domain_types.js';
 import { ShipmentMethod } from './shipment_method.js';
+import { RequestOptions } from '../request.js';
+
+export type StorefrontChangeRequestStatus =
+  | 'created'
+  | 'running'
+  | 'preview_ready'
+  | 'approved'
+  | 'rejected';
+
+export interface StorefrontChecksSummary {
+  overall?: 'passing' | 'failing' | 'pending' | 'unknown';
+  statusState?: string;
+  counts?: {
+    total?: number;
+    passed?: number;
+    failed?: number;
+    pending?: number;
+    neutral?: number;
+  };
+  updatedAt?: string;
+}
+
+export interface StorefrontV2ChangeRequest {
+  id: number;
+  domainId: number;
+  storefrontV2Id: number;
+  status: StorefrontChangeRequestStatus;
+  prompt: string;
+  branchName?: string | null;
+  commitSha?: string | null;
+  pullRequestNumber?: number | null;
+  previewUrl?: string | null;
+  summary?: string | null;
+  checksSummary?: StorefrontChecksSummary | null;
+  checksUpdatedAt?: string | null;
+  errorDetails?: string | null;
+}
 
 export class Domain extends Entity {
   protected static resourceName = 'domains';
@@ -291,4 +328,117 @@ export class Domain extends Entity {
     }
     return this.activeTheme!;
   };
+
+  private getDomainId = () => {
+    if (this.id === undefined || this.id === null) {
+      throw new Error('id is undefined, did you forget to set it?');
+    }
+    return this.id;
+  };
+
+  private storefrontV2DomainResource = (suffix = '') => {
+    return `/domains/${this.getDomainId()}/storefront_v2/${suffix}`;
+  };
+
+  private storefrontV2Request = (
+    resource: string,
+    method: 'GET' | 'POST',
+    payload?: Record<string, any>
+  ) => {
+    const fetchOptions: RequestOptions = {
+      method: method,
+      query: [['skip_rights', 'y']]
+    };
+    if (payload !== undefined) {
+      fetchOptions.body = JSON.stringify(payload);
+      fetchOptions.headers = {'Content-Type': 'application/json'};
+    }
+    return this.merchi.authenticatedFetch(resource, fetchOptions);
+  };
+
+  public getStorefrontV2 = () => {
+    return this.storefrontV2Request(this.storefrontV2DomainResource(), 'GET');
+  };
+
+  public provisionStorefrontV2 = (payload?: Record<string, any>) => {
+    return this.storefrontV2Request(
+      this.storefrontV2DomainResource('provision/'),
+      'POST',
+      payload
+    );
+  };
+
+  public createStorefrontChangeRequest = (
+    payload?: Record<string, any>
+  ): Promise<{storefrontChangeRequest: StorefrontV2ChangeRequest}> => {
+    return this.storefrontV2Request(
+      this.storefrontV2DomainResource('requests/'),
+      'POST',
+      payload
+    ) as Promise<{storefrontChangeRequest: StorefrontV2ChangeRequest}>;
+  };
+
+  public getStorefrontChangeRequest = (
+    requestId: number | string
+  ): Promise<{storefrontChangeRequest: StorefrontV2ChangeRequest}> => {
+    return this.storefrontV2Request(
+      `/storefront_change_requests/${String(requestId)}/`,
+      'GET'
+    ) as Promise<{storefrontChangeRequest: StorefrontV2ChangeRequest}>;
+  };
+
+  public runStorefrontChangeRequest = (
+    requestId: number | string,
+    payload?: Record<string, any>
+  ): Promise<{storefrontChangeRequest: StorefrontV2ChangeRequest}> => {
+    return this.storefrontV2Request(
+      `/storefront_change_requests/${String(requestId)}/run/`,
+      'POST',
+      payload
+    ) as Promise<{storefrontChangeRequest: StorefrontV2ChangeRequest}>;
+  };
+
+  public approveStorefrontChangeRequest = (
+    requestId: number | string,
+    payload?: Record<string, any>
+  ): Promise<{storefrontChangeRequest: StorefrontV2ChangeRequest}> => {
+    return this.storefrontV2Request(
+      `/storefront_change_requests/${String(requestId)}/approve/`,
+      'POST',
+      payload
+    ) as Promise<{storefrontChangeRequest: StorefrontV2ChangeRequest}>;
+  };
+
+  public rejectStorefrontChangeRequest = (
+    requestId: number | string,
+    payload?: Record<string, any>
+  ): Promise<{storefrontChangeRequest: StorefrontV2ChangeRequest}> => {
+    return this.storefrontV2Request(
+      `/storefront_change_requests/${String(requestId)}/reject/`,
+      'POST',
+      payload
+    ) as Promise<{storefrontChangeRequest: StorefrontV2ChangeRequest}>;
+  };
+
+  public getStorefrontV2Deployments = () => {
+    return this.storefrontV2Request(
+      this.storefrontV2DomainResource('deployments/'),
+      'GET'
+    );
+  };
+
+  public getStorefrontV2DeploymentLogs = (deploymentId: number | string) => {
+    return this.storefrontV2Request(
+      this.storefrontV2DomainResource(`deployments/${String(deploymentId)}/logs/`),
+      'GET'
+    );
+  };
+
+  public rollbackStorefrontV2 = (payload?: Record<string, any>) => {
+    return this.storefrontV2Request(
+      this.storefrontV2DomainResource('rollback/'),
+      'POST',
+      payload
+    );
+  };
 }

package/src/entities/notification.test.ts

@@ -22,37 +22,3 @@ test('can list notifications with notificationSender filter', () => {
     expect(query).toContainEqual(['notification_sender', '123']);
   });
 });
-
-test('list forwards skipCount=true as skip_count query param', () => {
-  const merchi = new Merchi();
-  const fetch = mockFetch(true, {
-    'notifications': [],
-    // backend returns ``available: null`` when skip_count was honoured
-    'available': null,
-    'count': 0
-  }, 200);
-  const options = { skipCount: true };
-  return merchi.Notification.list(options).then((response) => {
-    const query = fetch.mock.calls[0][1]['query'];
-    expect(query).toContainEqual(['skip_count', 'true']);
-    // ``available`` must round-trip as ``null``; the typed metadata
-    // is now ``number | null``, so consumers can detect the absence.
-    expect(response.metadata.available).toBeNull();
-  });
-});
-
-test('list omits skip_count when skipCount is not set', () => {
-  const merchi = new Merchi();
-  const fetch = mockFetch(true, {
-    'notifications': [],
-    'available': 0,
-    'count': 0
-  }, 200);
-  return merchi.Notification.list({}).then(() => {
-    const query = fetch.mock.calls[0][1]['query'];
-    const skipCountEntries = query.filter(
-      (entry: [string, string]) => entry[0] === 'skip_count'
-    );
-    expect(skipCountEntries).toEqual([]);
-  });
-});

package/src/entity.ts

@@ -159,22 +159,11 @@ interface ListOptions {
   teamOnly?: boolean;
   turnaroundTimeDays?: number;
   withRights?: boolean;
-  // Opt out of the unbounded ``SELECT count(*)`` the API runs to
-  // populate ``available``. When ``skipCount`` is true the response's
-  // ``available`` is ``null``. Use this whenever the caller only
-  // renders the visible page of rows (search modals, autocomplete,
-  // navbar dropdowns, infinite scroll, ...) and never reads
-  // ``metadata.available``. Paginated tables that show "Showing X
-  // of Y" or compute a page count must NOT set this.
-  skipCount?: boolean;
 }
 
 export interface ListMetadata {
   canCreate?: boolean;
-  // ``null`` when the caller passed ``skipCount: true``: the API
-  // intentionally skipped the ``COUNT(*)`` query. JSON consumers
-  // can detect the absence rather than mistaking it for zero.
-  available: number | null;
+  available: number;
   count: number;
   limit: number;
   offset: number;
@@ -428,16 +417,6 @@ export class Entity {
       if (options.limit !== undefined) {
         fetchOptions.query.push(['limit', options.limit.toString()]);
       }
-      if (options.skipCount !== undefined) {
-        // Snake-case is the canonical form on the server; the API
-        // also accepts ``skipCount`` via its camelCase alias, but
-        // matching the wire shape of the other ``*_only`` /
-        // ``*_filter`` flags keeps logs and traffic captures
-        // consistent.
-        fetchOptions.query.push(
-          ['skip_count', options.skipCount.toString()]
-        );
-      }
       if (options.q !== undefined) {
         fetchOptions.query.push(['q', options.q]);
       }