@kaiban/sdk 0.1.1 → 0.1.2

package/dist/lib/resources/ActivitiesClient.d.ts

@@ -1,7 +1,7 @@
+import { Activity, ActivityCreate } from '../../types/entities';
+import { ListParams, Paginated } from '../../types/responses';
 import { HttpClient } from '../http/HttpClient';
 import { RequestOptions } from '../http/types';
-import { CardActivity, ActivityCreate } from '../../types/entities';
-import { ListParams, Paginated } from '../../types/responses';
 /**
  * Client for managing card activities
  * Activities track changes, comments, and events on cards
@@ -11,70 +11,94 @@ export declare class ActivitiesClient {
     private readonly http;
     constructor(http: HttpClient);
     /**
-     * List activities for a specific card
-     * Supports pagination, filtering, and sorting through query parameters
+     * List all activities with pagination, filters, and sorting
+     * Returns activities across all cards (use filters to narrow down)
      *
-     * @param cardId - The unique identifier of the card
      * @param params - Optional query parameters for filtering and pagination
-     * @param params.cursor - Cursor for the next page of results
-     * @param params.limit - Number of items per page
-     * @param params.order_by - Fields to sort by
+     * @param params.limit - Number of items per page (default: 50, max: 100)
+     * @param params.after - Cursor to navigate forwards (get items after this cursor)
+     * @param params.before - Cursor to navigate backwards (get items before this cursor)
+     * @param params.order_by - Fields to sort by (prefix with - for descending order)
+     * @param params.filters - Filter parameters (e.g., { card_id: '123', type: 'comment' })
      * @param options - Optional request configuration
      *
      * @returns A paginated list of activities
      *
      * @example
      * ```typescript
-     * // Get activities for a card
-     * const result = await client.activities.list('card-123', {
+     * // Get activities with filters
+     * const result = await client.activities.list({
      *   limit: 20,
-     *   order_by: ['created_at']
+     *   order_by: '-created_at',
+     *   filters: { card_id: 'card-123', type: 'comment' }
      * });
+     * console.log(result.data); // Array of Activity objects
      *
-     * console.log(result.items); // Array of CardActivity objects
+     * // Get next page
+     * if (result.pagination.next_cursor) {
+     *   const nextPage = await client.activities.list({
+     *     limit: 20,
+     *     after: result.pagination.next_cursor
+     *   });
+     * }
      * ```
      */
-    list(cardId: string, params?: ListParams, options?: RequestOptions): Promise<Paginated<CardActivity>>;
+    list(params?: ListParams, options?: RequestOptions): Promise<Paginated<Activity>>;
     /**
-     * Iterate through all activities for a card using async generator
-     * Automatically handles pagination by following next_page_token
+     * Iterate through all activities using async generator
+     * Automatically handles pagination by following next_cursor
      *
-     * @param cardId - The unique identifier of the card
-     * @param params - Optional query parameters (excluding cursor)
+     * @param params - Optional query parameters (excluding after/before cursors)
+     * @param params.limit - Number of items per page (used internally for pagination)
+     * @param params.order_by - Fields to sort by (prefix with - for descending)
+     * @param params.filters - Filter parameters to narrow results
      * @param options - Optional request configuration
      *
-     * @yields Individual CardActivity objects
+     * @yields Individual Activity objects
      *
      * @example
      * ```typescript
-     * // Process all activities for a card
-     * for await (const activity of client.activities.listAll('card-123')) {
+     * // Process all activities
+     * for await (const activity of client.activities.listAll()) {
      *   console.log(activity.type, activity.description);
      * }
+     *
+     * // With filters and custom page size
+     * for await (const activity of client.activities.listAll({
+     *   limit: 100,
+     *   order_by: '-created_at',
+     *   filters: { card_id: 'card-123', type: 'comment' }
+     * })) {
+     *   console.log(activity);
+     * }
      * ```
      */
-    listAll(cardId: string, params?: Omit<ListParams, 'cursor'>, options?: RequestOptions): AsyncGenerator<CardActivity, void, unknown>;
+    listAll(params?: Omit<ListParams, 'after' | 'before'>, options?: RequestOptions): AsyncGenerator<Activity, void, unknown>;
     /**
-     * Create a new activity for a card
+     * Create a new activity
      * Activities can track various events such as comments, status changes, or custom events
      *
-     * @param cardId - The unique identifier of the card
      * @param data - Activity creation data
+     * @param data.card_id - The unique identifier of the card
+     * @param data.board_id - The board ID
+     * @param data.team_id - The team ID
      * @param data.type - The type of activity (e.g., 'card_created', 'card_updated', 'comment')
      * @param data.description - A description of the activity
      * @param data.actor - The actor who performed the activity
+     * @param data.changes - Optional array of field changes
+     * @param data.metadata - Optional additional metadata
      * @param options - Optional request configuration
      *
      * @returns The created activity object
      *
-     * @throws {Error} If the card is not found or creation fails
+     * @throws {Error} If creation fails
      *
      * @example
      * ```typescript
-     * const activity = await client.activities.create('card-123', {
+     * const activity = await client.activities.create({
+     *   card_id: 'card-123',
      *   board_id: 'board-456',
      *   team_id: 'team-789',
-     *   card_id: 'card-123',
      *   type: 'comment',
      *   description: 'Added a comment',
      *   actor: {
@@ -85,5 +109,40 @@ export declare class ActivitiesClient {
      * });
      * ```
      */
-    create(cardId: string, data: ActivityCreate, options?: RequestOptions): Promise<CardActivity>;
+    create(data: ActivityCreate, options?: RequestOptions): Promise<Activity>;
+    /**
+     * Create multiple activities in a single batch request
+     * This is more efficient than creating activities one by one
+     *
+     * @param data - Array of activity creation data
+     * @param options - Optional request configuration
+     *
+     * @returns The batch creation result
+     *
+     * @throws {Error} If batch creation fails
+     *
+     * @example
+     * ```typescript
+     * const activities = await client.activities.createBatch([
+     *   {
+     *     card_id: 'card-123',
+     *     board_id: 'board-456',
+     *     team_id: 'team-789',
+     *     type: 'comment',
+     *     description: 'First comment',
+     *     actor: { id: 'user-001', type: 'user', name: 'Jane Doe' }
+     *   },
+     *   {
+     *     card_id: 'card-123',
+     *     board_id: 'board-456',
+     *     team_id: 'team-789',
+     *     type: 'card_updated',
+     *     description: 'Updated priority',
+     *     actor: { id: 'user-001', type: 'user', name: 'Jane Doe' },
+     *     changes: [{ field: 'priority', old_value: 'low', new_value: 'high' }]
+     *   }
+     * ]);
+     * ```
+     */
+    createBatch(data: ActivityCreate[], options?: RequestOptions): Promise<Activity>;
 }

package/dist/lib/resources/ActivitiesClient.js

@@ -9,80 +9,104 @@ export class ActivitiesClient {
         this.http = http;
     }
     /**
-     * List activities for a specific card
-     * Supports pagination, filtering, and sorting through query parameters
+     * List all activities with pagination, filters, and sorting
+     * Returns activities across all cards (use filters to narrow down)
      *
-     * @param cardId - The unique identifier of the card
      * @param params - Optional query parameters for filtering and pagination
-     * @param params.cursor - Cursor for the next page of results
-     * @param params.limit - Number of items per page
-     * @param params.order_by - Fields to sort by
+     * @param params.limit - Number of items per page (default: 50, max: 100)
+     * @param params.after - Cursor to navigate forwards (get items after this cursor)
+     * @param params.before - Cursor to navigate backwards (get items before this cursor)
+     * @param params.order_by - Fields to sort by (prefix with - for descending order)
+     * @param params.filters - Filter parameters (e.g., { card_id: '123', type: 'comment' })
      * @param options - Optional request configuration
      *
      * @returns A paginated list of activities
      *
      * @example
      * ```typescript
-     * // Get activities for a card
-     * const result = await client.activities.list('card-123', {
+     * // Get activities with filters
+     * const result = await client.activities.list({
      *   limit: 20,
-     *   order_by: ['created_at']
+     *   order_by: '-created_at',
+     *   filters: { card_id: 'card-123', type: 'comment' }
      * });
+     * console.log(result.data); // Array of Activity objects
      *
-     * console.log(result.items); // Array of CardActivity objects
+     * // Get next page
+     * if (result.pagination.next_cursor) {
+     *   const nextPage = await client.activities.list({
+     *     limit: 20,
+     *     after: result.pagination.next_cursor
+     *   });
+     * }
      * ```
      */
-    list(cardId, params, options) {
-        return this.http.list(`/card/${encodeURIComponent(cardId)}/activities`, params, options);
+    list(params, options) {
+        return this.http.list(`/activities`, params, options);
     }
     /**
-     * Iterate through all activities for a card using async generator
-     * Automatically handles pagination by following next_page_token
+     * Iterate through all activities using async generator
+     * Automatically handles pagination by following next_cursor
      *
-     * @param cardId - The unique identifier of the card
-     * @param params - Optional query parameters (excluding cursor)
+     * @param params - Optional query parameters (excluding after/before cursors)
+     * @param params.limit - Number of items per page (used internally for pagination)
+     * @param params.order_by - Fields to sort by (prefix with - for descending)
+     * @param params.filters - Filter parameters to narrow results
      * @param options - Optional request configuration
      *
-     * @yields Individual CardActivity objects
+     * @yields Individual Activity objects
      *
      * @example
      * ```typescript
-     * // Process all activities for a card
-     * for await (const activity of client.activities.listAll('card-123')) {
+     * // Process all activities
+     * for await (const activity of client.activities.listAll()) {
      *   console.log(activity.type, activity.description);
      * }
+     *
+     * // With filters and custom page size
+     * for await (const activity of client.activities.listAll({
+     *   limit: 100,
+     *   order_by: '-created_at',
+     *   filters: { card_id: 'card-123', type: 'comment' }
+     * })) {
+     *   console.log(activity);
+     * }
      * ```
      */
-    async *listAll(cardId, params, options) {
+    async *listAll(params, options) {
         let cursor = undefined;
         do {
-            const page = await this.list(cardId, { ...(params || {}), cursor }, options);
+            const page = await this.list({ ...(params || {}), after: cursor }, options);
             for (const item of page.data)
                 yield item;
-            cursor = page.meta.next_cursor;
+            cursor = page.pagination.next_cursor;
         } while (cursor);
     }
     /**
-     * Create a new activity for a card
+     * Create a new activity
      * Activities can track various events such as comments, status changes, or custom events
      *
-     * @param cardId - The unique identifier of the card
      * @param data - Activity creation data
+     * @param data.card_id - The unique identifier of the card
+     * @param data.board_id - The board ID
+     * @param data.team_id - The team ID
      * @param data.type - The type of activity (e.g., 'card_created', 'card_updated', 'comment')
      * @param data.description - A description of the activity
      * @param data.actor - The actor who performed the activity
+     * @param data.changes - Optional array of field changes
+     * @param data.metadata - Optional additional metadata
      * @param options - Optional request configuration
      *
      * @returns The created activity object
      *
-     * @throws {Error} If the card is not found or creation fails
+     * @throws {Error} If creation fails
      *
      * @example
      * ```typescript
-     * const activity = await client.activities.create('card-123', {
+     * const activity = await client.activities.create({
+     *   card_id: 'card-123',
      *   board_id: 'board-456',
      *   team_id: 'team-789',
-     *   card_id: 'card-123',
      *   type: 'comment',
      *   description: 'Added a comment',
      *   actor: {
@@ -93,7 +117,44 @@ export class ActivitiesClient {
      * });
      * ```
      */
-    create(cardId, data, options) {
-        return this.http.post(`/card/${encodeURIComponent(cardId)}/activities`, data, options);
+    create(data, options) {
+        return this.http.post(`/activities:batch`, { items: [data] }, options);
+    }
+    /**
+     * Create multiple activities in a single batch request
+     * This is more efficient than creating activities one by one
+     *
+     * @param data - Array of activity creation data
+     * @param options - Optional request configuration
+     *
+     * @returns The batch creation result
+     *
+     * @throws {Error} If batch creation fails
+     *
+     * @example
+     * ```typescript
+     * const activities = await client.activities.createBatch([
+     *   {
+     *     card_id: 'card-123',
+     *     board_id: 'board-456',
+     *     team_id: 'team-789',
+     *     type: 'comment',
+     *     description: 'First comment',
+     *     actor: { id: 'user-001', type: 'user', name: 'Jane Doe' }
+     *   },
+     *   {
+     *     card_id: 'card-123',
+     *     board_id: 'board-456',
+     *     team_id: 'team-789',
+     *     type: 'card_updated',
+     *     description: 'Updated priority',
+     *     actor: { id: 'user-001', type: 'user', name: 'Jane Doe' },
+     *     changes: [{ field: 'priority', old_value: 'low', new_value: 'high' }]
+     *   }
+     * ]);
+     * ```
+     */
+    createBatch(data, options) {
+        return this.http.post(`/activities:batch`, { items: data }, options);
     }
 }

package/dist/lib/resources/AgentsClient.d.ts

@@ -1,7 +1,7 @@
+import { Agent, AgentFeedback, AgentSupervisorFeedback } from '../../types/entities';
+import { ListParams, Paginated } from '../../types/responses';
 import { HttpClient } from '../http/HttpClient';
 import { RequestOptions } from '../http/types';
-import { Agent, AgentFeedback } from '../../types/entities';
-import { ListParams, Paginated } from '../../types/responses';
 /**
  * Client for managing agents in the Kaiban platform
  * @category Resources
@@ -13,9 +13,11 @@ export declare class AgentsClient {
      * List agents with pagination, filters, and sorting
      *
      * @param params - Optional query parameters for filtering and pagination
-     * @param params.cursor - Cursor for the next page of results
-     * @param params.limit - Number of items per page
-     * @param params.order_by - Fields to sort by
+     * @param params.limit - Number of items per page (default: 50, max: 100)
+     * @param params.after - Cursor to navigate forwards (get items after this cursor)
+     * @param params.before - Cursor to navigate backwards (get items before this cursor)
+     * @param params.order_by - Fields to sort by (prefix with - for descending order)
+     * @param params.filters - Filter parameters to narrow results
      * @param options - Optional request configuration
      *
      * @returns A paginated list of agents
@@ -24,22 +26,34 @@ export declare class AgentsClient {
      * ```typescript
      * // List first page of agents
      * const result = await client.agents.list({ limit: 10 });
-     * console.log(result.items); // Array of Agent objects
+     * console.log(result.data); // Array of Agent objects
+     * console.log(result.pagination.next_cursor); // Cursor for next page
      *
      * // Get next page using cursor
-     * if (result.next_page_token) {
+     * if (result.pagination.next_cursor) {
      *   const nextPage = await client.agents.list({
-     *     cursor: result.next_page_token
+     *     limit: 10,
+     *     after: result.pagination.next_cursor
      *   });
      * }
+     *
+     * // With filters and sorting
+     * const filtered = await client.agents.list({
+     *   limit: 20,
+     *   order_by: '-created_at',
+     *   filters: { status: 'active' }
+     * });
      * ```
      */
     list(params?: ListParams, options?: RequestOptions): Promise<Paginated<Agent>>;
     /**
      * Iterate through all agents using async generator
-     * Automatically handles pagination by following next_page_token
+     * Automatically handles pagination by following next_cursor
      *
-     * @param params - Optional query parameters (excluding cursor)
+     * @param params - Optional query parameters (excluding after/before cursors)
+     * @param params.limit - Number of items per page (used internally for pagination)
+     * @param params.order_by - Fields to sort by (prefix with - for descending order)
+     * @param params.filters - Filter parameters to narrow results
      * @param options - Optional request configuration
      *
      * @yields Individual Agent objects
@@ -51,15 +65,17 @@ export declare class AgentsClient {
      *   console.log(agent.id, agent.name);
      * }
      *
-     * // With filtering
+     * // With custom page size and sorting
      * for await (const agent of client.agents.listAll({
-     *   order_by: ['created_at']
+     *   limit: 100,
+     *   order_by: '-created_at',
+     *   filters: { status: 'active' }
      * })) {
      *   console.log(agent);
      * }
      * ```
      */
-    listAll(params?: Omit<ListParams, 'cursor'>, options?: RequestOptions): AsyncGenerator<Agent, void, unknown>;
+    listAll(params?: Omit<ListParams, 'after' | 'before'>, options?: RequestOptions): AsyncGenerator<Agent, void, unknown>;
     /**
      * Get a single agent by ID
      *
@@ -100,7 +116,7 @@ export declare class AgentsClient {
     /**
      * Create feedback for an agent
      *
-     * @param id - The unique identifier of the agent
+     * @param agentId - The unique identifier of the agent
      * @param feedback - Feedback data to submit
      * @param options - Optional request configuration
      *
@@ -117,5 +133,42 @@ export declare class AgentsClient {
      * });
      * ```
      */
-    createFeedback(id: string, feedback: AgentFeedback, options?: RequestOptions): Promise<void>;
+    createFeedback(agentId: string, feedback: Omit<AgentFeedback, 'id' | 'agent_id' | 'created_at'>, options?: RequestOptions): Promise<AgentFeedback>;
+    /**
+     * List supervisor feedback for a specific agent with pagination
+     *
+     * @param agentId - The unique identifier of the agent
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.limit - Number of items per page (default: 50, max: 100)
+     * @param params.after - Cursor to navigate forwards (get items after this cursor)
+     * @param params.before - Cursor to navigate backwards (get items before this cursor)
+     * @param params.order_by - Fields to sort by (prefix with - for descending order)
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of supervisor feedback for the agent
+     *
+     * @throws {Error} If the agent is not found or request fails
+     *
+     * @example
+     * ```typescript
+     * // List supervisor feedback for an agent
+     * const result = await client.agents.listSupervisorFeedbacks('agent-123', {
+     *   limit: 10,
+     *   order_by: '-created_at'
+     * });
+     *
+     * for (const feedback of result.data) {
+     *   console.log(feedback.rating, feedback.comment);
+     * }
+     *
+     * // Get next page if available
+     * if (result.pagination.next_cursor) {
+     *   const nextPage = await client.agents.listSupervisorFeedbacks('agent-123', {
+     *     limit: 10,
+     *     after: result.pagination.next_cursor
+     *   });
+     * }
+     * ```
+     */
+    listSupervisorFeedback(agentId: string, params?: ListParams, options?: RequestOptions): Promise<Paginated<AgentSupervisorFeedback>>;
 }

package/dist/lib/resources/AgentsClient.js

@@ -10,9 +10,11 @@ export class AgentsClient {
      * List agents with pagination, filters, and sorting
      *
      * @param params - Optional query parameters for filtering and pagination
-     * @param params.cursor - Cursor for the next page of results
-     * @param params.limit - Number of items per page
-     * @param params.order_by - Fields to sort by
+     * @param params.limit - Number of items per page (default: 50, max: 100)
+     * @param params.after - Cursor to navigate forwards (get items after this cursor)
+     * @param params.before - Cursor to navigate backwards (get items before this cursor)
+     * @param params.order_by - Fields to sort by (prefix with - for descending order)
+     * @param params.filters - Filter parameters to narrow results
      * @param options - Optional request configuration
      *
      * @returns A paginated list of agents
@@ -21,14 +23,23 @@ export class AgentsClient {
      * ```typescript
      * // List first page of agents
      * const result = await client.agents.list({ limit: 10 });
-     * console.log(result.items); // Array of Agent objects
+     * console.log(result.data); // Array of Agent objects
+     * console.log(result.pagination.next_cursor); // Cursor for next page
      *
      * // Get next page using cursor
-     * if (result.next_page_token) {
+     * if (result.pagination.next_cursor) {
      *   const nextPage = await client.agents.list({
-     *     cursor: result.next_page_token
+     *     limit: 10,
+     *     after: result.pagination.next_cursor
      *   });
      * }
+     *
+     * // With filters and sorting
+     * const filtered = await client.agents.list({
+     *   limit: 20,
+     *   order_by: '-created_at',
+     *   filters: { status: 'active' }
+     * });
      * ```
      */
     list(params, options) {
@@ -36,9 +47,12 @@ export class AgentsClient {
     }
     /**
      * Iterate through all agents using async generator
-     * Automatically handles pagination by following next_page_token
+     * Automatically handles pagination by following next_cursor
      *
-     * @param params - Optional query parameters (excluding cursor)
+     * @param params - Optional query parameters (excluding after/before cursors)
+     * @param params.limit - Number of items per page (used internally for pagination)
+     * @param params.order_by - Fields to sort by (prefix with - for descending order)
+     * @param params.filters - Filter parameters to narrow results
      * @param options - Optional request configuration
      *
      * @yields Individual Agent objects
@@ -50,22 +64,24 @@ export class AgentsClient {
      *   console.log(agent.id, agent.name);
      * }
      *
-     * // With filtering
+     * // With custom page size and sorting
      * for await (const agent of client.agents.listAll({
-     *   order_by: ['created_at']
+     *   limit: 100,
+     *   order_by: '-created_at',
+     *   filters: { status: 'active' }
      * })) {
      *   console.log(agent);
      * }
      * ```
      */
     async *listAll(params, options) {
-        let pageToken = undefined;
+        let cursor = undefined;
         do {
-            const page = await this.list({ ...(params || {}), cursor: pageToken }, options);
+            const page = await this.list({ ...(params || {}), after: cursor }, options);
             for (const item of page.data)
                 yield item;
-            pageToken = page.meta.next_cursor;
-        } while (pageToken);
+            cursor = page.pagination.next_cursor;
+        } while (cursor);
     }
     /**
      * Get a single agent by ID
@@ -111,7 +127,7 @@ export class AgentsClient {
     /**
      * Create feedback for an agent
      *
-     * @param id - The unique identifier of the agent
+     * @param agentId - The unique identifier of the agent
      * @param feedback - Feedback data to submit
      * @param options - Optional request configuration
      *
@@ -128,7 +144,49 @@ export class AgentsClient {
      * });
      * ```
      */
-    createFeedback(id, feedback, options) {
-        return this.http.post(`/agent/${encodeURIComponent(id)}/feedback`, feedback, options);
+    createFeedback(agentId, feedback, options) {
+        return this.http.post(`/agent/${encodeURIComponent(agentId)}/feedback`, {
+            ...feedback,
+            agent_id: agentId,
+        }, options);
+    }
+    /**
+     * List supervisor feedback for a specific agent with pagination
+     *
+     * @param agentId - The unique identifier of the agent
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.limit - Number of items per page (default: 50, max: 100)
+     * @param params.after - Cursor to navigate forwards (get items after this cursor)
+     * @param params.before - Cursor to navigate backwards (get items before this cursor)
+     * @param params.order_by - Fields to sort by (prefix with - for descending order)
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of supervisor feedback for the agent
+     *
+     * @throws {Error} If the agent is not found or request fails
+     *
+     * @example
+     * ```typescript
+     * // List supervisor feedback for an agent
+     * const result = await client.agents.listSupervisorFeedbacks('agent-123', {
+     *   limit: 10,
+     *   order_by: '-created_at'
+     * });
+     *
+     * for (const feedback of result.data) {
+     *   console.log(feedback.rating, feedback.comment);
+     * }
+     *
+     * // Get next page if available
+     * if (result.pagination.next_cursor) {
+     *   const nextPage = await client.agents.listSupervisorFeedbacks('agent-123', {
+     *     limit: 10,
+     *     after: result.pagination.next_cursor
+     *   });
+     * }
+     * ```
+     */
+    listSupervisorFeedback(agentId, params, options) {
+        return this.http.list(`/supervisor-feedback/${encodeURIComponent(agentId)}`, params, options);
     }
 }

package/dist/lib/resources/BoardsClient.d.ts

@@ -1,7 +1,7 @@
-import { HttpClient } from '../http/HttpClient';
-import { RequestOptions } from '../http/types';
 import { Board } from '../../types/entities';
 import { ListParams, Paginated } from '../../types/responses';
+import { HttpClient } from '../http/HttpClient';
+import { RequestOptions } from '../http/types';
 /**
  * Client for managing boards in the Kaiban platform
  * Boards organize cards into columns for workflow management
@@ -44,7 +44,7 @@ export declare class BoardsClient {
      * }
      * ```
      */
-    listAll(params?: Omit<ListParams, 'cursor'>, options?: RequestOptions): AsyncGenerator<Board, void, unknown>;
+    listAll(params?: Omit<ListParams, 'after' | 'before'>, options?: RequestOptions): AsyncGenerator<Board, void, unknown>;
     /**
      * Get a single board by ID
      *

package/dist/lib/resources/BoardsClient.js

@@ -46,10 +46,10 @@ export class BoardsClient {
     async *listAll(params, options) {
         let cursor = undefined;
         do {
-            const page = await this.list({ ...(params || {}), cursor: cursor }, options);
+            const page = await this.list({ ...(params || {}), after: cursor }, options);
             for (const item of page.data)
                 yield item;
-            cursor = page.meta.next_cursor;
+            cursor = page.pagination.next_cursor;
         } while (cursor);
     }
     /**