@api-client/core 0.18.38 → 0.18.40

package/src/sdk/SdkMock.ts

@@ -1,51 +1,53 @@
-import { nanoid } from '../nanoid.js'
+import {
+  type ResponseGenerator,
+  setupWorker,
+  type MockHandler,
+  type SetupWorkerOptions,
+  type InterceptOptions,
+} from '@jarrodek/amw'
 import type { IOrganization } from '../models/store/Organization.js'
 import type { GroupSchema } from '../models/store/Group.js'
 import type { IUser } from '../models/store/User.js'
 import type { InvitationSchema } from '../models/store/Invitation.js'
-import { OrganizationKind, GroupKind, InvitationKind } from '../models/kinds.js'
-import { Kind as UserKind } from '../models/store/User.js'
-import { File, type IFile, type FileBreadcrumb } from '../models/store/File.js'
-import { CertificateFileKind, DomainFileKind, FolderKind, ProjectKind } from '../models/kinds.js'
+import { type IFile, type FileBreadcrumb } from '../models/store/File.js'
 import type { ContextListResult, IBulkOperationResult } from '../events/BaseEvents.js'
-import type { MediaPatchRevision } from '../patch/types.js'
-import type { IFolder } from '../models/Folder.js'
 import type { TrashEntry } from '../models/TrashEntry.js'
-import type { StoreSdk } from './StoreSdkWeb.js'
-import * as sinon from 'sinon'
-import { Exception } from '../exceptions/exception.js'
+import { RouteBuilder } from './RouteBuilder.js'
+import { ModelingMock } from '../mocking/ModelingMock.js'
 
-/**
- * Options for customizing mock responses.
- */
-export interface MockResponseOptions {
-  /**
-   * Custom response data to return instead of generated random data.
-   */
-  data?: unknown
+export interface MockResult {
   /**
-   * HTTP status code to return. Defaults to 200.
+   * Custom response generator for the mock intercept.
    */
-  status?: number
+  response?: ResponseGenerator
   /**
-   * Custom headers to include in the response.
+   * If true, the request body will be generated using the body generator.
+   * It is useful when only setting up response headers or status code, but
+   * the request body should still be generated, even when missing in the `response` option.
    */
-  headers?: Record<string, string>
+  forceBody?: boolean
 }
 
-/**
- * A stub reference that can be used to restore the original behavior.
- */
-export interface StubReference {
+export interface MockListResult extends MockResult {
+  /**
+   * Number of items to generate in the list response.
+   */
+  size?: number
   /**
-   * Restores the original behavior.
+   * If true, the response will include a cursor for pagination.
+   * If false, the response will not include a cursor.
+   * If not set, a random choice will be made.
    */
-  restore: () => void
+  cursor?: boolean
 }
 
 /**
- * SDK mocking utility for testing. Provides simple API to mock SDK calls
- * with random or custom responses.
+ * SDK mocking utility for testing. Uses Service Workers to intercept HTTP requests
+ * and provide mock responses for API calls.
+ *
+ * This class uses the `@jarrodek/amw` library to set up a Service Worker that intercepts
+ * fetch requests matching the configured routes. Each method adds an intercept for a specific
+ * API endpoint, returning either random generated data or custom responses.
  *
  * @example
  * ```typescript
@@ -53,194 +55,527 @@ export interface StubReference {
  * import { StoreSdk } from '@api-client/core/sdk/StoreSdkWeb.js';
  *
  * const sdk = new StoreSdk('http://localhost:8080');
- * const mocker = new SdkMock(sdk);
+ * const mocker = new SdkMock({
+ *   swPath: '/mockServiceWorker.js', // Path to the Service Worker script
+ *   base: 'http://localhost:8080'    // Base URL matching the SDK
+ * });
+ *
+ * // Initialize the Service Worker
+ * await mocker.setup();
+ *
+ * // Add intercept - returns random organizations
+ * await mocker.organizations.list();
  *
- * // Simple usage - returns random valid organization
- * const stub1 = mocker.organizations.list();
+ * // Custom response with specific data
+ * await mocker.organizations.create({
+ *   response: {
+ *     status: 201,
+ *     headers: { 'Content-Type': 'application/json', 'X-Custom-Header': 'value' },
+ *     body: JSON.stringify({ key: 'custom-id', name: 'Custom Org' })
+ *   }
+ * });
  *
- * // Custom response
- * const stub2 = mocker.organizations.create({
- *   data: { key: 'org-1', name: 'Test Org', ... }
+ * // Control pagination in list responses
+ * await mocker.groups.list({
+ *   size: 10,        // Number of items to generate
+ *   cursor: true     // Include pagination cursor
  * });
  *
- * // Custom status and headers
- * const stub3 = mocker.users.me({
- *   status: 404,
- *   headers: { 'X-Custom': 'value' }
+ * // Error simulation
+ * await mocker.users.me({
+ *   response: {
+ *     status: 404,
+ *     headers: { 'Content-Type': 'application/json' },
+ *     body: JSON.stringify({ error: 'Not found' })
+ *   }
  * });
  *
- * // Restore all stubs
- * mocker.restore();
+ * // Remove all intercepts (keep Service Worker active)
+ * await mocker.reset();
+ *
+ * // Stop and remove the Service Worker
+ * await mocker.teardown();
  * ```
+ *
+ * @TODO: Add a in-memory state store so that mocks can maintain state across requests.
+ * This way, operations like create, update, delete can affect subsequent list/read calls
+ * and we can mimic the API behavior more closely.
  */
 export class SdkMock {
-  private stubs: StubReference[] = []
+  handler?: MockHandler
+  gen = new ModelingMock()
+
+  constructor(public options?: SetupWorkerOptions) {}
+
+  /**
+   * Initializes the mock handler. It uses options provided in the constructor.
+   * It has to be called before using any of the mock methods.
+   */
+  async setup(): Promise<void> {
+    this.handler = await setupWorker(this.options)
+  }
+
+  /**
+   * Removes the mock worker and all intercepts.
+   */
+  async teardown(): Promise<void> {
+    await this.mock.stop()
+  }
+
+  /**
+   * Removes all added intercepts.
+   */
+  async reset(): Promise<void> {
+    await this.mock.reset()
+  }
+
+  get mock(): MockHandler {
+    if (!this.handler) {
+      throw new Error('Mock handler not initialized. Call setup() first.')
+    }
+    return this.handler
+  }
+
+  protected createCursorOption(init: MockListResult = {}): string | undefined {
+    if (init.cursor === false) {
+      return undefined
+    }
+    const hasCursor = init.cursor === true ? true : this.gen.faker.datatype.boolean()
+    if (!hasCursor) {
+      return undefined
+    }
+    return this.gen.faker.internet.jwt()
+  }
 
-  constructor(private sdk: StoreSdk) {}
+  protected createDefaultResponse(
+    status: number,
+    headers?: Record<string, string>,
+    body?: () => string,
+    userConfig?: MockResult
+  ): ResponseGenerator {
+    let respond: ResponseGenerator
+    if (userConfig?.response) {
+      // user config takes precedence
+      respond = userConfig.response
+    } else {
+      respond = {}
+    }
+    // Set defaults if not provided in user config
+    if (!respond.status) {
+      respond.status = status
+    }
+    // only set headers if the user didn't configure the response only.
+    // The user may want to remove default headers.
+    if (!userConfig || !userConfig.response) {
+      respond.headers = headers
+    }
+    if (!respond.body && userConfig?.forceBody && body) {
+      // when body is missing and forceBody is set, generate the body
+      respond.body = body()
+    } else if (body && (!userConfig || !userConfig.response)) {
+      // we set the body by default when the user config is missing
+      respond.body = body()
+    }
+    return respond
+  }
 
   /**
    * Organization API mocks.
    */
   organizations = {
     /**
-     * Mocks the `organizations.list()` method.
-     * @param options Optional response customization.
-     * @returns A stub reference that can be used to restore the original behavior.
+     * Adds an intercept to mock the `organizations.list()` method.
+     * @param options Optional response configuration
      */
-    list: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('organizations', 'list', () => {
-        const defaultData = {
-          items: [this.generateOrganization(), this.generateOrganization()],
-          nextPageToken: undefined,
-        }
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    list: async (init?: MockListResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify({
+      //     items: this.gen.organization.organizations(init?.size ?? 5),
+      //     cursor: this.createCursorOption(init),
+      //   } as ContextListResult<IOrganization>),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () =>
+          JSON.stringify({
+            items: this.gen.organization.organizations(init?.size ?? 5),
+            cursor: this.createCursorOption(init),
+          } as ContextListResult<IOrganization>),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.organizations(),
+            methods: ['GET'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
-     * Mocks the `organizations.create()` method.
-     * @param options Optional response customization.
-     * @returns A stub reference that can be used to restore the original behavior.
+     * Adds an intercept to mock the `organizations.create()` method.
+     * @param options Optional response configuration
      */
-    create: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('organizations', 'create', () => {
-        const defaultData = this.generateOrganization()
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    create: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify(this.gen.organization.organization()),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => JSON.stringify(this.gen.organization.organization()),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.organizations(),
+            methods: ['POST'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     invitations: {
-      list: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.invitations', 'list', () => {
-          const defaultData = {
-            items: [this.generateInvitation(), this.generateInvitation()],
-          }
-          if (options?.status !== undefined && options.status !== 200) {
-            throw new Exception('Mocked error', { status: options.status })
-          }
-          return (options?.data ?? defaultData) as unknown
-        })
+      list: async (init?: MockListResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        // const respond = init?.response ?? {
+        //   status: 200,
+        //   headers: { 'content-type': 'application/json' },
+        //   body: JSON.stringify({
+        //     items: this.gen.invitation.invitations(init?.size ?? 5),
+        //     cursor: this.createCursorOption(init),
+        //   } as ContextListResult<InvitationSchema>),
+        // }
+        const respond = this.createDefaultResponse(
+          200,
+          { 'content-type': 'application/json' },
+          () => {
+            const obj: ContextListResult<InvitationSchema> = {
+              items: this.gen.invitation.invitations(init?.size ?? 5),
+              cursor: this.createCursorOption(init),
+            }
+            return JSON.stringify(obj)
+          },
+          init
+        )
+        await mock.add(
+          {
+            match: {
+              uri: RouteBuilder.invitations(':oid'),
+              methods: ['GET'],
+            },
+            respond,
+          },
+          options
+        )
       },
-      create: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.invitations', 'create', () => {
-          const defaultData = this.generateInvitation()
-          if (options?.status !== undefined && options.status !== 200) {
-            throw new Exception('Mocked error', { status: options.status })
-          }
-          return (options?.data ?? defaultData) as unknown
-        })
+      create: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        // const respond = init?.response ?? {
+        //   status: 200,
+        //   headers: { 'content-type': 'application/json' },
+        //   body: JSON.stringify(this.gen.invitation.invitation()),
+        // }
+        const respond = this.createDefaultResponse(
+          200,
+          { 'content-type': 'application/json' },
+          () => JSON.stringify(this.gen.invitation.invitation()),
+          init
+        )
+        await mock.add(
+          {
+            match: {
+              uri: RouteBuilder.invitations(':oid'),
+              methods: ['POST'],
+            },
+            respond,
+          },
+          options
+        )
       },
-      findByToken: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.invitations', 'findByToken', () => {
-          const defaultData = this.generateInvitation()
-          if (options?.status !== undefined && options.status !== 200) {
-            throw new Exception('Mocked error', { status: options.status })
-          }
-          return (options?.data ?? defaultData) as unknown
-        })
+      findByToken: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        // const respond = init?.response ?? {
+        //   status: 200,
+        //   headers: { 'content-type': 'application/json' },
+        //   body: JSON.stringify(this.gen.invitation.invitation()),
+        // }
+        const respond = this.createDefaultResponse(
+          200,
+          { 'content-type': 'application/json' },
+          () => JSON.stringify(this.gen.invitation.invitation()),
+          init
+        )
+
+        await mock.add(
+          {
+            match: {
+              uri: RouteBuilder.findInvitation(),
+              methods: ['GET'],
+            },
+            respond,
+          },
+          options
+        )
       },
-      decline: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.invitations', 'decline', () => {
-          const defaultData = this.generateInvitation()
-          if (options?.status !== undefined && options.status !== 200) {
-            throw new Exception('Mocked error', { status: options.status })
-          }
-          return (options?.data ?? defaultData) as unknown
-        })
+      decline: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        // const respond = init?.response ?? {
+        //   status: 200,
+        //   headers: { 'content-type': 'application/json' },
+        //   body: JSON.stringify(this.gen.invitation.invitation()),
+        // }
+        const respond = this.createDefaultResponse(
+          200,
+          { 'content-type': 'application/json' },
+          () => JSON.stringify(this.gen.invitation.invitation()),
+          init
+        )
+
+        await mock.add(
+          {
+            match: {
+              uri: RouteBuilder.declineInvitation(':oid', ':id'),
+              methods: ['POST'],
+            },
+            respond,
+          },
+          options
+        )
       },
-      delete: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.invitations', 'delete', () => {
-          const defaultData = this.generateInvitation()
-          if (options?.status !== undefined && options.status !== 200) {
-            throw new Exception('Mocked error', { status: options.status })
-          }
-          return (options?.data ?? defaultData) as unknown
-        })
+      delete: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        // const respond = init?.response ?? {
+        //   status: 200,
+        //   headers: { 'content-type': 'application/json' },
+        //   body: JSON.stringify(this.gen.invitation.invitation()),
+        // }
+        const respond = this.createDefaultResponse(
+          200,
+          { 'content-type': 'application/json' },
+          () => JSON.stringify(this.gen.invitation.invitation()),
+          init
+        )
+
+        await mock.add(
+          {
+            match: {
+              uri: RouteBuilder.invitation(':oid', ':id'),
+              methods: ['DELETE'],
+            },
+            respond,
+          },
+          options
+        )
       },
-      patch: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.invitations', 'patch', () => {
-          const defaultData = this.generateInvitation()
-          if (options?.status !== undefined && options.status !== 200) {
-            throw new Exception('Mocked error', { status: options.status })
-          }
-          return (options?.data ?? defaultData) as unknown
-        })
+      patch: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        // const respond = init?.response ?? {
+        //   status: 200,
+        //   headers: { 'content-type': 'application/json' },
+        //   body: JSON.stringify(this.gen.invitation.invitation()),
+        // }
+        const respond = this.createDefaultResponse(
+          200,
+          { 'content-type': 'application/json' },
+          () => JSON.stringify(this.gen.invitation.invitation()),
+          init
+        )
+        await mock.add(
+          {
+            match: {
+              uri: RouteBuilder.invitation(':oid', ':id'),
+              methods: ['PATCH'],
+            },
+            respond,
+          },
+          options
+        )
       },
-      resend: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.invitations', 'resend', () => {
-          const defaultData = this.generateInvitation()
-          if (options?.status !== undefined && options.status !== 200) {
-            throw new Exception('Mocked error', { status: options.status })
-          }
-          return (options?.data ?? defaultData) as unknown
-        })
+      resend: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        // const respond = init?.response ?? {
+        //   status: 200,
+        //   headers: { 'content-type': 'application/json' },
+        //   body: JSON.stringify(this.gen.invitation.invitation()),
+        // }
+        const respond = this.createDefaultResponse(
+          200,
+          { 'content-type': 'application/json' },
+          () => JSON.stringify(this.gen.invitation.invitation()),
+          init
+        )
+
+        await mock.add(
+          {
+            match: {
+              uri: RouteBuilder.resendInvitation(':oid', ':id'),
+              methods: ['PUT'],
+            },
+            respond,
+          },
+          options
+        )
       },
     },
 
     users: {
-      list: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.users', 'list', () => {
-          const defaultData = {
-            items: [this.generateUser(), this.generateUser()],
-          }
-          if (options?.status !== undefined && options.status !== 200) {
-            throw new Exception('Mocked error', { status: options.status })
-          }
-          return (options?.data ?? defaultData) as unknown
-        })
+      list: async (init?: MockListResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        // const respond = init?.response ?? {
+        //   status: 200,
+        //   headers: { 'content-type': 'application/json' },
+        //   body: JSON.stringify({
+        //     items: this.gen.user.users(init?.size ?? 5),
+        //     cursor: this.createCursorOption(init),
+        //   } as ContextListResult<IUser>),
+        // }
+        const respond = this.createDefaultResponse(
+          200,
+          { 'content-type': 'application/json' },
+          () => {
+            const obj: ContextListResult<IUser> = {
+              items: this.gen.user.users(init?.size ?? 5),
+              cursor: this.createCursorOption(init),
+            }
+            return JSON.stringify(obj)
+          },
+          init
+        )
+        await mock.add(
+          {
+            match: {
+              uri: RouteBuilder.organizationUsers(':oid'),
+              methods: ['GET'],
+            },
+            respond,
+          },
+          options
+        )
       },
-      read: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.users', 'read', () => {
-          const defaultData = this.generateUser()
-          if (options?.status !== undefined && options.status !== 200) {
-            throw new Exception('Mocked error', { status: options.status })
-          }
-          return (options?.data ?? defaultData) as unknown
-        })
+      read: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        // const respond = init?.response ?? {
+        //   status: 200,
+        //   headers: { 'content-type': 'application/json' },
+        //   body: JSON.stringify(this.gen.user.user()),
+        // }
+        const respond = this.createDefaultResponse(
+          200,
+          { 'content-type': 'application/json' },
+          () => JSON.stringify(this.gen.user.user()),
+          init
+        )
+        await mock.add(
+          {
+            match: {
+              uri: RouteBuilder.organizationUser(':oid', ':id'),
+              methods: ['GET'],
+            },
+            respond,
+          },
+          options
+        )
       },
-      readBatch: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.users', 'readBatch', () => {
-          const defaultData = {
-            items: [this.generateUser(), this.generateUser()],
-          }
-          if (options?.status !== undefined && options.status !== 200) {
-            throw new Exception('Mocked error', { status: options.status })
-          }
-          return (options?.data ?? defaultData) as unknown
-        })
+      readBatch: async (init?: MockListResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        const path = RouteBuilder.organizationUserBatch(':oid')
+        const respond = init?.response ?? {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({
+            items: this.gen.user.users(init?.size ?? 5),
+            cursor: this.createCursorOption(init),
+          } as ContextListResult<IUser>),
+        }
+        await mock.add(
+          {
+            match: {
+              uri: path,
+              methods: ['POST'],
+            },
+            respond,
+          },
+          options
+        )
       },
-      activate: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.users', 'activate', () => {
-          const defaultData = this.generateUser()
-          if (options?.status !== undefined && options.status !== 200) {
-            throw new Exception('Mocked error', { status: options.status })
-          }
-          return (options?.data ?? defaultData) as unknown
-        })
+      activate: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        // const respond = init?.response ?? {
+        //   status: 200,
+        //   headers: { 'content-type': 'application/json' },
+        //   body: JSON.stringify(this.gen.user.user()),
+        // }
+        const respond = this.createDefaultResponse(
+          200,
+          { 'content-type': 'application/json' },
+          () => JSON.stringify(this.gen.user.user()),
+          init
+        )
+        await mock.add(
+          {
+            match: {
+              uri: RouteBuilder.organizationUserActivate(':oid', ':id'),
+              methods: ['POST'],
+            },
+            respond,
+          },
+          options
+        )
       },
-      deactivate: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.users', 'deactivate', () => {
-          const defaultData = this.generateUser()
-          if (options?.status !== undefined && options.status !== 200) {
-            throw new Exception('Mocked error', { status: options.status })
-          }
-          return (options?.data ?? defaultData) as unknown
-        })
+      deactivate: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        // const respond = init?.response ?? {
+        //   status: 200,
+        //   headers: { 'content-type': 'application/json' },
+        //   body: JSON.stringify(this.gen.user.user()),
+        // }
+        const respond = this.createDefaultResponse(
+          200,
+          { 'content-type': 'application/json' },
+          () => JSON.stringify(this.gen.user.user()),
+          init
+        )
+        await mock.add(
+          {
+            match: {
+              uri: RouteBuilder.organizationUserDeactivate(':oid', ':id'),
+              methods: ['POST'],
+            },
+            respond,
+          },
+          options
+        )
       },
-      delete: (options?: MockResponseOptions): StubReference => {
-        return this.createStub('organizations.users', 'delete', () => {
-          const status = options?.status ?? 204
-          if (status !== 204) {
-            throw new Exception('Mocked error', { status })
-          }
-          return undefined
-        })
+      delete: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+        const { mock } = this
+        // const respond = init?.response ?? {
+        //   status: 204,
+        // }
+        const respond = this.createDefaultResponse(204, undefined, undefined, init)
+        await mock.add(
+          {
+            match: {
+              uri: RouteBuilder.organizationUser(':oid', ':id'),
+              methods: ['DELETE'],
+            },
+            respond,
+          },
+          options
+        )
       },
     },
   }
@@ -252,106 +587,175 @@ export class SdkMock {
     /**
      * Mocks the `groups.list()` method.
      * @param options Optional response customization.
-     * @returns A stub reference that can be used to restore the original behavior.
      */
-    list: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('groups', 'list', () => {
-        const defaultData = {
-          items: [this.generateGroup(), this.generateGroup()],
-          nextPageToken: undefined,
-        }
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    list: async (init?: MockListResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify({
+      //     items: this.gen.group.groups(init?.size ?? 5),
+      //     cursor: this.createCursorOption(init),
+      //   } as ContextListResult<GroupSchema>),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => {
+          const obj: ContextListResult<GroupSchema> = {
+            items: this.gen.group.groups(init?.size ?? 5),
+            cursor: this.createCursorOption(init),
+          }
+          return JSON.stringify(obj)
+        },
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.groups(':oid'),
+            methods: ['GET'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `groups.create()` method.
      * @param options Optional response customization.
-     * @returns A stub reference that can be used to restore the original behavior.
-     */
-    create: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('groups', 'create', () => {
-        const defaultData = this.generateGroup()
-        const status = options?.status ?? 201
-        if (status !== 201) {
-          throw new Exception('Mocked error', { status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
-    },
-
-    /**
-     * Mocks the `groups.read()` method.
-     * @param options Optional response customization.
-     * @returns A stub reference that can be used to restore the original behavior.
      */
-    read: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('groups', 'read', () => {
-        const defaultData = this.generateGroup()
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    create: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 201,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify(this.gen.group.group()),
+      // }
+      const respond = this.createDefaultResponse(
+        201,
+        { 'content-type': 'application/json' },
+        () => JSON.stringify(this.gen.group.group()),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.groups(':oid'),
+            methods: ['POST'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `groups.update()` method.
      * @param options Optional response customization.
-     * @returns A stub reference that can be used to restore the original behavior.
      */
-    update: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('groups', 'update', () => {
-        const defaultData = this.generateGroup()
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    update: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify(this.gen.group.group()),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => JSON.stringify(this.gen.group.group()),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.group(':oid', ':key'),
+            methods: ['PATCH'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `groups.delete()` method.
      * @param options Optional response customization.
-     * @returns A stub reference that can be used to restore the original behavior.
      */
-    delete: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('groups', 'delete', () => {
-        const status = options?.status ?? 204
-        if (status !== 204) {
-          throw new Exception('Mocked error', { status })
-        }
-        return undefined
-      })
+    delete: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 204,
+      // }
+      const respond = this.createDefaultResponse(204, undefined, undefined, init)
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.group(':oid', ':key'),
+            methods: ['DELETE'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `groups.addUsers()` method.
      */
-    addUsers: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('groups', 'addUsers', () => {
-        const defaultData = this.generateGroup()
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    addUsers: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify(this.gen.group.group()),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => JSON.stringify(this.gen.group.group()),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.groupUsers(':oid', ':key'),
+            methods: ['POST'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `groups.removeUsers()` method.
      */
-    removeUsers: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('groups', 'removeUsers', () => {
-        const defaultData = this.generateGroup()
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    removeUsers: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify(this.gen.group.group()),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => JSON.stringify(this.gen.group.group()),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.groupUsers(':oid', ':key'),
+            methods: ['DELETE'],
+          },
+          respond,
+        },
+        options
+      )
     },
   }
 
@@ -362,16 +766,30 @@ export class SdkMock {
     /**
      * Mocks the `user.me()` method.
      * @param options Optional response customization.
-     * @returns A stub reference that can be used to restore the original behavior.
      */
-    me: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('user', 'me', () => {
-        const defaultData = this.generateUser()
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception(`Mocked error. Status: ${options.status}`, { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    me: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify(this.gen.user.user()),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => JSON.stringify(this.gen.user.user()),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.usersMe(),
+            methods: ['GET'],
+          },
+          respond,
+        },
+        options
+      )
     },
   }
 
@@ -382,233 +800,437 @@ export class SdkMock {
     /**
      * Mocks the `file.list()` method.
      */
-    list: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'list', () => {
-        const defaultData: ContextListResult<IFile> = {
-          items: [this.generateFile(), this.generateFile()],
-        }
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    list: async (init?: MockListResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify({
+      //     items: this.gen.file.files(init?.size ?? 5),
+      //     cursor: this.createCursorOption(init),
+      //   } as ContextListResult<IFile>),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => {
+          const obj: ContextListResult<IFile> = {
+            items: this.gen.file.files(init?.size ?? 5),
+            cursor: this.createCursorOption(init),
+          }
+          return JSON.stringify(obj)
+        },
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.files(':oid'),
+            methods: ['GET'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.createMeta()` method.
      */
-    createMeta: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'createMeta', () => {
-        const defaultData: IFile = this.generateFile()
-        const status = options?.status ?? 201
-        if (status !== 201) {
-          throw new Exception('Mocked error', { status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    createMeta: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 201,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify(this.gen.file.file()),
+      // }
+      const respond = this.createDefaultResponse(
+        201,
+        { 'content-type': 'application/json' },
+        () => JSON.stringify(this.gen.file.file()),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.files(':oid'),
+            methods: ['POST'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.createMedia()` method.
      */
-    createMedia: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'createMedia', () => {
-        const status = options?.status ?? 200
-        if (status !== 200) {
-          throw new Exception('Mocked error', { status })
-        }
-        return undefined
-      })
+    createMedia: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      // }
+      const respond = this.createDefaultResponse(200, undefined, undefined, init)
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.fileMedia(':oid', ':id'),
+            methods: ['PUT'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.create()` method.
      */
-    create: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'create', () => {
-        const status = options?.status ?? 201
-        if (status !== 201) {
-          throw new Exception('Mocked error', { status })
-        }
-        const defaultData: IFile = this.generateFile()
-        return (options?.data ?? defaultData) as unknown
-      })
+    create: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      await this.file.createMeta(init, options)
+      // When SDK's file.create() is called, it responds with
+      // what the result of file.createMeta() would be.
+      // Because of that, we don't need to configure the media request.
+      await this.file.createMedia(undefined, options)
     },
 
     /**
      * Mocks the `file.createFolder()` method.
      */
-    createFolder: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'createFolder', () => {
-        const status = options?.status ?? 201
-        if (status !== 201) {
-          throw new Exception('Mocked error', { status })
-        }
-        const defaultData: IFolder = this.generateFolder()
-        return (options?.data ?? defaultData) as unknown
-      })
+    createFolder: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 201,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify(this.gen.file.folder()),
+      // }
+      const respond = this.createDefaultResponse(
+        201,
+        { 'content-type': 'application/json' },
+        () => JSON.stringify(this.gen.file.folder()),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.files(':oid'),
+            methods: ['POST'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.read()` method.
      */
-    read: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'read', () => {
-        const defaultData: IFile = this.generateFile()
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    read: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify(this.gen.file.file()),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => JSON.stringify(this.gen.file.file()),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.file(':oid', ':id'),
+            methods: ['GET'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.readMedia()` method.
      */
-    readMedia: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'readMedia', () => {
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        const defaultData = { media: { ok: true }, version: 1 }
-        return (options?.data ?? defaultData) as unknown
-      })
+    readMedia: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: {
+      //     'content-type': 'application/json',
+      //     'x-version': `${this.gen.faker.number.int({ min: 1, max: 100 })}`,
+      //   },
+      //   body: JSON.stringify({ data: this.gen.faker.lorem.sentences() }),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        {
+          'content-type': 'application/json',
+          'x-version': `${this.gen.faker.number.int({ min: 1, max: 100 })}`,
+        },
+        () => JSON.stringify({ data: this.gen.faker.lorem.sentences() }),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.fileMedia(':oid', ':id'),
+            methods: ['GET'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.readBulk()` method.
      */
-    readBulk: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'readBulk', () => {
-        const defaultData: IBulkOperationResult<IFile> = {
-          items: [this.generateFile(), undefined],
-        }
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    readBulk: async (init?: MockListResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify({
+      //     items: this.gen.file.files(init?.size ?? 5),
+      //   } as IBulkOperationResult<IFile>),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => {
+          const obj: IBulkOperationResult<IFile> = {
+            items: this.gen.file.files(init?.size ?? 5),
+          }
+          return JSON.stringify(obj)
+        },
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.filesBatch(':oid'),
+            methods: ['POST'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.patch()` method.
      */
-    patch: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'patch', () => {
-        const defaultData: IFile = this.generateFile()
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    patch: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify(this.gen.file.file()),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => JSON.stringify(this.gen.file.file()),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.file(':oid', ':id'),
+            methods: ['PATCH'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.patchMedia()` method.
      */
-    patchMedia: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'patchMedia', () => {
-        const defaultData: MediaPatchRevision = this.generateMediaPatchRevision()
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    patchMedia: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify(this.gen.patch.mediaPatchRevision()),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => JSON.stringify(this.gen.patch.mediaPatchRevision()),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.fileMedia(':oid', ':id'),
+            methods: ['PATCH'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.delete()` method.
      */
-    delete: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'delete', () => {
-        const status = options?.status ?? 204
-        if (status !== 204) {
-          throw new Exception('Mocked error', { status })
-        }
-        return undefined
-      })
+    delete: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 204,
+      // }
+      const respond = this.createDefaultResponse(204, undefined, undefined, init)
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.file(':oid', ':id'),
+            methods: ['DELETE'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.deleteBulk()` method.
      */
-    deleteBulk: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'deleteBulk', () => {
-        const status = options?.status ?? 204
-        if (status !== 204) {
-          throw new Exception('Mocked error', { status })
-        }
-        return undefined
-      })
+    deleteBulk: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 204,
+      // }
+      const respond = this.createDefaultResponse(204, undefined, undefined, init)
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.files(':oid'),
+            methods: ['DELETE'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.patchUsers()` method.
      */
-    patchUsers: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'patchUsers', () => {
-        const defaultData: IFile = this.generateFile()
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    patchUsers: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify(this.gen.file.file()),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => JSON.stringify(this.gen.file.file()),
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.filesAccess(':oid', ':id'),
+            methods: ['PATCH'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.addUser()` method.
      */
-    addUser: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'addUser', () => {
-        const defaultData: IFile = this.generateFile()
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    addUser: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      await this.file.patchUsers(init, options)
     },
 
     /**
      * Mocks the `file.removeUser()` method.
      */
-    removeUser: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'removeUser', () => {
-        const defaultData: IFile = this.generateFile()
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    removeUser: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      await this.file.patchUsers(init, options)
     },
 
     /**
      * Mocks the `file.listUsers()` method.
      */
-    listUsers: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'listUsers', () => {
-        const defaultData: ContextListResult<IUser> = {
-          items: [this.generateUser(), this.generateUser()],
-        }
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    listUsers: async (init?: MockListResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify({
+      //     items: this.gen.user.users(init?.size ?? 5),
+      //     cursor: this.createCursorOption(init),
+      //   } as ContextListResult<IUser>),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => {
+          const obj: ContextListResult<IUser> = {
+            items: this.gen.user.users(init?.size ?? 5),
+            cursor: this.createCursorOption(init),
+          }
+          return JSON.stringify(obj)
+        },
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.fileUsers(':oid', ':id'),
+            methods: ['GET'],
+          },
+          respond,
+        },
+        options
+      )
     },
 
     /**
      * Mocks the `file.breadcrumbs()` method.
      */
-    breadcrumbs: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('file', 'breadcrumbs', () => {
-        const defaultData: ContextListResult<FileBreadcrumb> = {
-          items: this.generateBreadcrumbs(),
-        }
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    breadcrumbs: async (init?: MockListResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify({
+      //     items: this.gen.file.fileBreadcrumbs(init?.size ?? 5),
+      //     cursor: this.createCursorOption(init),
+      //   } as ContextListResult<FileBreadcrumb>),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => {
+          const obj: ContextListResult<FileBreadcrumb> = {
+            items: this.gen.file.fileBreadcrumbs(init?.size ?? 5),
+            cursor: this.createCursorOption(init),
+          }
+          return JSON.stringify(obj)
+        },
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.fileBreadcrumbs(':oid', ':id'),
+            methods: ['GET'],
+          },
+          respond,
+        },
+        options
+      )
     },
   }
 
@@ -616,16 +1238,38 @@ export class SdkMock {
    * Shared API mocks.
    */
   shared = {
-    list: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('shared', 'list', () => {
-        const defaultData: ContextListResult<IFile> = {
-          items: [this.generateFile(), this.generateFile()],
-        }
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
+    list: async (init?: MockListResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify({
+      //     items: this.gen.file.files(init?.size ?? 5),
+      //     cursor: this.createCursorOption(init),
+      //   } as ContextListResult<IFile>),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => {
+          const obj: ContextListResult<IFile> = {
+            items: this.gen.file.files(init?.size ?? 5),
+            cursor: this.createCursorOption(init),
+          }
+          return JSON.stringify(obj)
+        },
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.shared(':oid'),
+            methods: ['GET'],
+          },
+          respond,
+        },
+        options
+      )
     },
   }
 
@@ -633,284 +1277,89 @@ export class SdkMock {
    * Trash API mocks.
    */
   trash = {
-    list: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('trash', 'list', () => {
-        const defaultData: ContextListResult<TrashEntry> = {
-          items: [this.generateTrashEntry(), this.generateTrashEntry()],
-        }
-        if (options?.status !== undefined && options.status !== 200) {
-          throw new Exception('Mocked error', { status: options.status })
-        }
-        return (options?.data ?? defaultData) as unknown
-      })
-    },
-    delete: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('trash', 'delete', () => {
-        const status = options?.status ?? 204
-        if (status !== 204) {
-          throw new Exception('Mocked error', { status })
-        }
-        return undefined
-      })
-    },
-    restore: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('trash', 'restore', () => {
-        const status = options?.status ?? 204
-        if (status !== 204) {
-          throw new Exception('Mocked error', { status })
-        }
-        return undefined
-      })
-    },
-    empty: (options?: MockResponseOptions): StubReference => {
-      return this.createStub('trash', 'empty', () => {
-        const status = options?.status ?? 204
-        if (status !== 204) {
-          throw new Exception('Mocked error', { status })
-        }
-        return undefined
-      })
+    list: async (init?: MockListResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 200,
+      //   headers: { 'content-type': 'application/json' },
+      //   body: JSON.stringify({
+      //     items: this.gen.trash.trashEntries(init?.size ?? 5),
+      //     cursor: this.createCursorOption(init),
+      //   } as ContextListResult<TrashEntry>),
+      // }
+      const respond = this.createDefaultResponse(
+        200,
+        { 'content-type': 'application/json' },
+        () => {
+          const obj: ContextListResult<TrashEntry> = {
+            items: this.gen.trash.trashEntries(init?.size ?? 5),
+            cursor: this.createCursorOption(init),
+          }
+          return JSON.stringify(obj)
+        },
+        init
+      )
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.trash(':oid'),
+            methods: ['GET'],
+          },
+          respond,
+        },
+        options
+      )
     },
-  }
-
-  /**
-   * Restores all stubs created by this mocker.
-   */
-  restore(): void {
-    this.stubs.forEach((stub) => stub.restore())
-    this.stubs = []
-  }
-
-  /**
-   * Creates a stub for a specific SDK method.
-   * @param api The API name (e.g., 'organizations', 'groups', 'user', 'auth').
-   * @param method The method name to stub.
-   * @param implementation The stub implementation that returns the mocked data.
-   * @returns A stub reference.
-   */
-  private createStub(
-    api:
-      | 'organizations'
-      | 'groups'
-      | 'user'
-      | 'auth'
-      | 'file'
-      | 'shared'
-      | 'trash'
-      | 'organizations.invitations'
-      | 'organizations.users',
-    method: string,
-    implementation: () => unknown
-  ): StubReference {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let target: any = this.sdk
-    const parts = api.split('.')
-    for (const part of parts) {
-      target = target[part]
-      if (!target) {
-        throw new Error(`API '${api}' not found in SDK`)
-      }
-    }
-
-    const original = target[method]
-    if (typeof original !== 'function') {
-      throw new Error(`Method '${method}' not found in ${api} API`)
-    }
-
-    // Create stub using sinon
-    const stub = sinon.stub(target, method).callsFake(async () => implementation())
-
-    const stubRef: StubReference = {
-      restore: () => {
-        if (stub) {
-          stub.restore()
-        }
-        const index = this.stubs.indexOf(stubRef)
-        if (index > -1) {
-          this.stubs.splice(index, 1)
-        }
-      },
-    }
-
-    this.stubs.push(stubRef)
-    return stubRef
-  }
-
-  /**
-   * Generates a random organization object.
-   */
-  private generateOrganization(): IOrganization {
-    return {
-      kind: OrganizationKind,
-      key: nanoid(),
-      name: `Organization ${this.randomString()}`,
-      createdBy: nanoid(),
-      createdDate: Date.now() - Math.random() * 1000 * 60 * 60 * 24 * 30,
-      grantType: this.randomChoice(['owner', 'manager', 'editor', 'viewer'] as const),
-    }
-  }
-
-  /**
-   * Generates a random group object.
-   */
-  private generateGroup(): GroupSchema {
-    return {
-      kind: GroupKind,
-      key: nanoid(),
-      name: `Group ${this.randomString()}`,
-      description: `Description for ${this.randomString()}`,
-      owner: nanoid(),
-      oid: nanoid(),
-      users: [],
-      createdAt: Date.now() - Math.random() * 1000 * 60 * 60 * 24 * 30,
-      updatedAt: Date.now() - Math.random() * 1000 * 60 * 60 * 24 * 7,
-      icon: `https://example.com/icon-${nanoid()}.png`,
-      color: this.randomColor(),
-    }
-  }
-
-  /**
-   * Generates a random user object.
-   */
-  private generateUser(): IUser {
-    const firstName = this.randomString()
-    const lastName = this.randomString()
-    return {
-      kind: UserKind,
-      key: nanoid(),
-      name: `${firstName} ${lastName}`,
-      email: [
+    delete: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 204,
+      // }
+      const respond = this.createDefaultResponse(204, undefined, undefined, init)
+      await mock.add(
         {
-          email: `${firstName.toLowerCase()}.${lastName.toLowerCase()}@example.com`,
-          verified: true,
+          match: {
+            uri: RouteBuilder.trashBatchDelete(':oid'),
+            methods: ['DELETE'],
+          },
+          respond,
         },
-      ],
-      status: 'active',
-      created: Date.now() - Math.random() * 1000 * 60 * 60 * 24 * 365,
-      updated: Date.now() - Math.random() * 1000 * 60 * 60 * 24 * 7,
-    }
-  }
-
-  /**
-   * Generates a random file meta object.
-   */
-  private generateFile(): IFile {
-    const kind = this.randomChoice([ProjectKind, DomainFileKind, CertificateFileKind, FolderKind] as const)
-    const name = `File ${this.randomString()}`
-    return File.createSchema({ kind, info: { name } })
-  }
-
-  /**
-   * Generates a random folder meta object.
-   */
-  private generateFolder(): IFolder {
-    const file = File.createSchema({ kind: FolderKind, info: { name: `Folder ${this.randomString()}` } }) as IFolder
-    return file
-  }
-
-  /**
-   * Generates a random media patch revision object.
-   */
-  private generateMediaPatchRevision(): MediaPatchRevision {
-    const version = Math.floor(Math.random() * 10) + 1
-    return {
-      id: nanoid(),
-      timestamp: Date.now(),
-      patch: [],
-      version,
-      revert: [],
-      newVersion: version + 1,
-    }
-  }
-
-  /**
-   * Generates a random breadcrumbs list.
-   */
-  private generateBreadcrumbs(): FileBreadcrumb[] {
-    const depth = 2 + Math.floor(Math.random() * 2) // 2-3
-    const items: FileBreadcrumb[] = []
-    for (let i = 0; i < depth; i += 1) {
-      items.push({ key: nanoid(), kind: i === depth - 1 ? ProjectKind : FolderKind, name: this.randomString() })
-    }
-    return items
-  }
-
-  /**
-   * Generates a random invitation object.
-   */
-  private generateInvitation(): InvitationSchema {
-    const firstName = this.randomString()
-    const lastName = this.randomString()
-    const now = Date.now()
-    return {
-      kind: InvitationKind,
-      key: nanoid(),
-      uid: nanoid(),
-      oid: nanoid(),
-      email: `${firstName.toLowerCase()}.${lastName.toLowerCase()}@example.com`,
-      name: `${firstName} ${lastName}`,
-      token: nanoid(),
-      expiresAt: now + 7 * 24 * 60 * 60 * 1000,
-      status: 'pending',
-      grantType: this.randomChoice(['owner', 'manager', 'editor', 'viewer'] as const),
-      createdAt: now - Math.random() * 1000 * 60 * 60 * 24,
-      updatedAt: now - Math.random() * 1000 * 60 * 60,
-      resent: 0,
-      lastSentAt: now - Math.random() * 1000 * 60 * 60,
-    }
-  }
-
-  /**
-   * Generates a random trash entry.
-   */
-  private generateTrashEntry(): TrashEntry {
-    return {
-      key: nanoid(),
-      refKey: nanoid(),
-      kind: this.randomChoice([ProjectKind, DomainFileKind, CertificateFileKind, FolderKind] as const),
-      name: `Deleted ${this.randomString()}`,
-      info: { byMe: false, time: Date.now() - Math.floor(Math.random() * 1000000), user: nanoid(), name: 'User' },
-      capabilities: { canDelete: true, canRestore: true },
-    }
-  }
-
-  /**
-   * Generates a random string.
-   */
-  private randomString(): string {
-    const words = [
-      'Alpha',
-      'Beta',
-      'Gamma',
-      'Delta',
-      'Epsilon',
-      'Zeta',
-      'Theta',
-      'Lambda',
-      'Sigma',
-      'Omega',
-      'Phoenix',
-      'Dragon',
-      'Tiger',
-      'Eagle',
-      'Falcon',
-    ]
-    return words[Math.floor(Math.random() * words.length)]
-  }
-
-  /**
-   * Returns a random choice from an array.
-   */
-  private randomChoice<T>(choices: readonly T[]): T {
-    return choices[Math.floor(Math.random() * choices.length)]
-  }
-
-  /**
-   * Generates a random hex color.
-   */
-  private randomColor(): string {
-    return `#${Math.floor(Math.random() * 16777215)
-      .toString(16)
-      .padStart(6, '0')}`
+        options
+      )
+    },
+    restore: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 204,
+      // }
+      const respond = this.createDefaultResponse(204, undefined, undefined, init)
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.trashBatchRestore(':oid'),
+            methods: ['POST'],
+          },
+          respond,
+        },
+        options
+      )
+    },
+    empty: async (init?: MockResult, options?: InterceptOptions): Promise<void> => {
+      const { mock } = this
+      // const respond = init?.response ?? {
+      //   status: 204,
+      // }
+      const respond = this.createDefaultResponse(204, undefined, undefined, init)
+      await mock.add(
+        {
+          match: {
+            uri: RouteBuilder.trashEmpty(':oid'),
+            methods: ['DELETE'],
+          },
+          respond,
+        },
+        options
+      )
+    },
   }
 }