@api-client/core 0.18.38 → 0.18.40

package/build/src/sdk/SdkMock.js

@@ -1,13 +1,13 @@
-import { nanoid } from '../nanoid.js';
-import { OrganizationKind, GroupKind, InvitationKind } from '../models/kinds.js';
-import { Kind as UserKind } from '../models/store/User.js';
-import { File } from '../models/store/File.js';
-import { CertificateFileKind, DomainFileKind, FolderKind, ProjectKind } from '../models/kinds.js';
-import * as sinon from 'sinon';
-import { Exception } from '../exceptions/exception.js';
+import { setupWorker, } from '@jarrodek/amw';
+import { RouteBuilder } from './RouteBuilder.js';
+import { ModelingMock } from '../mocking/ModelingMock.js';
 /**
- * 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
@@ -15,192 +15,401 @@ import { Exception } from '../exceptions/exception.js';
  * 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
+ * });
  *
- * // Simple usage - returns random valid organization
- * const stub1 = mocker.organizations.list();
+ * // Initialize the Service Worker
+ * await mocker.setup();
  *
- * // Custom response
- * const stub2 = mocker.organizations.create({
- *   data: { key: 'org-1', name: 'Test Org', ... }
+ * // Add intercept - returns random organizations
+ * await 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 status and headers
- * const stub3 = mocker.users.me({
- *   status: 404,
- *   headers: { 'X-Custom': 'value' }
+ * // Control pagination in list responses
+ * await mocker.groups.list({
+ *   size: 10,        // Number of items to generate
+ *   cursor: true     // Include pagination cursor
  * });
  *
- * // Restore all stubs
- * mocker.restore();
+ * // Error simulation
+ * await mocker.users.me({
+ *   response: {
+ *     status: 404,
+ *     headers: { 'Content-Type': 'application/json' },
+ *     body: JSON.stringify({ error: 'Not found' })
+ *   }
+ * });
+ *
+ * // 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 {
-    sdk;
-    stubs = [];
-    constructor(sdk) {
-        this.sdk = sdk;
+    options;
+    handler;
+    gen = new ModelingMock();
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * 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() {
+        this.handler = await setupWorker(this.options);
+    }
+    /**
+     * Removes the mock worker and all intercepts.
+     */
+    async teardown() {
+        await this.mock.stop();
+    }
+    /**
+     * Removes all added intercepts.
+     */
+    async reset() {
+        await this.mock.reset();
+    }
+    get mock() {
+        if (!this.handler) {
+            throw new Error('Mock handler not initialized. Call setup() first.');
+        }
+        return this.handler;
+    }
+    createCursorOption(init = {}) {
+        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();
+    }
+    createDefaultResponse(status, headers, body, userConfig) {
+        let respond;
+        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) => {
-            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);
-            });
+        list: async (init, options) => {
+            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),
+            }), 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) => {
-            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);
-            });
+        create: async (init, options) => {
+            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) => {
-                return this.createStub('organizations.invitations', 'list', () => {
-                    const defaultData = {
-                        items: [this.generateInvitation(), this.generateInvitation()],
+            list: async (init, options) => {
+                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 = {
+                        items: this.gen.invitation.invitations(init?.size ?? 5),
+                        cursor: this.createCursorOption(init),
                     };
-                    if (options?.status !== undefined && options.status !== 200) {
-                        throw new Exception('Mocked error', { status: options.status });
-                    }
-                    return (options?.data ?? defaultData);
-                });
+                    return JSON.stringify(obj);
+                }, init);
+                await mock.add({
+                    match: {
+                        uri: RouteBuilder.invitations(':oid'),
+                        methods: ['GET'],
+                    },
+                    respond,
+                }, options);
             },
-            create: (options) => {
-                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);
-                });
+            create: async (init, options) => {
+                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) => {
-                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);
-                });
+            findByToken: async (init, options) => {
+                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) => {
-                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);
-                });
+            decline: async (init, options) => {
+                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) => {
-                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);
-                });
+            delete: async (init, options) => {
+                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) => {
-                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);
-                });
+            patch: async (init, options) => {
+                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) => {
-                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);
-                });
+            resend: async (init, options) => {
+                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) => {
-                return this.createStub('organizations.users', 'list', () => {
-                    const defaultData = {
-                        items: [this.generateUser(), this.generateUser()],
+            list: async (init, options) => {
+                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 = {
+                        items: this.gen.user.users(init?.size ?? 5),
+                        cursor: this.createCursorOption(init),
                     };
-                    if (options?.status !== undefined && options.status !== 200) {
-                        throw new Exception('Mocked error', { status: options.status });
-                    }
-                    return (options?.data ?? defaultData);
-                });
+                    return JSON.stringify(obj);
+                }, init);
+                await mock.add({
+                    match: {
+                        uri: RouteBuilder.organizationUsers(':oid'),
+                        methods: ['GET'],
+                    },
+                    respond,
+                }, options);
             },
-            read: (options) => {
-                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);
-                });
+            read: async (init, options) => {
+                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) => {
-                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);
-                });
+            readBatch: async (init, options) => {
+                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),
+                    }),
+                };
+                await mock.add({
+                    match: {
+                        uri: path,
+                        methods: ['POST'],
+                    },
+                    respond,
+                }, options);
             },
-            activate: (options) => {
-                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);
-                });
+            activate: async (init, options) => {
+                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) => {
-                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);
-                });
+            deactivate: async (init, options) => {
+                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) => {
-                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, options) => {
+                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);
             },
         },
     };
@@ -211,100 +420,127 @@ 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) => {
-            return this.createStub('groups', 'list', () => {
-                const defaultData = {
-                    items: [this.generateGroup(), this.generateGroup()],
-                    nextPageToken: undefined,
+        list: async (init, options) => {
+            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 = {
+                    items: this.gen.group.groups(init?.size ?? 5),
+                    cursor: this.createCursorOption(init),
                 };
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
+                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) => {
-            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);
-            });
-        },
-        /**
-         * 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) => {
-            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);
-            });
+        create: async (init, options) => {
+            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) => {
-            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);
-            });
+        update: async (init, options) => {
+            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) => {
-            return this.createStub('groups', 'delete', () => {
-                const status = options?.status ?? 204;
-                if (status !== 204) {
-                    throw new Exception('Mocked error', { status });
-                }
-                return undefined;
-            });
+        delete: async (init, options) => {
+            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) => {
-            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);
-            });
+        addUsers: async (init, options) => {
+            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) => {
-            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);
-            });
+        removeUsers: async (init, options) => {
+            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);
         },
     };
     /**
@@ -314,16 +550,22 @@ 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) => {
-            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);
-            });
+        me: async (init, options) => {
+            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);
         },
     };
     /**
@@ -333,487 +575,427 @@ export class SdkMock {
         /**
          * Mocks the `file.list()` method.
          */
-        list: (options) => {
-            return this.createStub('file', 'list', () => {
-                const defaultData = {
-                    items: [this.generateFile(), this.generateFile()],
+        list: async (init, options) => {
+            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 = {
+                    items: this.gen.file.files(init?.size ?? 5),
+                    cursor: this.createCursorOption(init),
                 };
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
+                return JSON.stringify(obj);
+            }, init);
+            await mock.add({
+                match: {
+                    uri: RouteBuilder.files(':oid'),
+                    methods: ['GET'],
+                },
+                respond,
+            }, options);
         },
         /**
          * Mocks the `file.createMeta()` method.
          */
-        createMeta: (options) => {
-            return this.createStub('file', 'createMeta', () => {
-                const defaultData = this.generateFile();
-                const status = options?.status ?? 201;
-                if (status !== 201) {
-                    throw new Exception('Mocked error', { status });
-                }
-                return (options?.data ?? defaultData);
-            });
+        createMeta: async (init, options) => {
+            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) => {
-            return this.createStub('file', 'createMedia', () => {
-                const status = options?.status ?? 200;
-                if (status !== 200) {
-                    throw new Exception('Mocked error', { status });
-                }
-                return undefined;
-            });
+        createMedia: async (init, options) => {
+            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) => {
-            return this.createStub('file', 'create', () => {
-                const status = options?.status ?? 201;
-                if (status !== 201) {
-                    throw new Exception('Mocked error', { status });
-                }
-                const defaultData = this.generateFile();
-                return (options?.data ?? defaultData);
-            });
+        create: async (init, options) => {
+            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) => {
-            return this.createStub('file', 'createFolder', () => {
-                const status = options?.status ?? 201;
-                if (status !== 201) {
-                    throw new Exception('Mocked error', { status });
-                }
-                const defaultData = this.generateFolder();
-                return (options?.data ?? defaultData);
-            });
+        createFolder: async (init, options) => {
+            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) => {
-            return this.createStub('file', 'read', () => {
-                const defaultData = this.generateFile();
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
+        read: async (init, options) => {
+            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) => {
-            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);
-            });
+        readMedia: async (init, options) => {
+            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) => {
-            return this.createStub('file', 'readBulk', () => {
-                const defaultData = {
-                    items: [this.generateFile(), undefined],
+        readBulk: async (init, options) => {
+            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 = {
+                    items: this.gen.file.files(init?.size ?? 5),
                 };
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
+                return JSON.stringify(obj);
+            }, init);
+            await mock.add({
+                match: {
+                    uri: RouteBuilder.filesBatch(':oid'),
+                    methods: ['POST'],
+                },
+                respond,
+            }, options);
         },
         /**
          * Mocks the `file.patch()` method.
          */
-        patch: (options) => {
-            return this.createStub('file', 'patch', () => {
-                const defaultData = this.generateFile();
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
+        patch: async (init, options) => {
+            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) => {
-            return this.createStub('file', 'patchMedia', () => {
-                const defaultData = this.generateMediaPatchRevision();
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
+        patchMedia: async (init, options) => {
+            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) => {
-            return this.createStub('file', 'delete', () => {
-                const status = options?.status ?? 204;
-                if (status !== 204) {
-                    throw new Exception('Mocked error', { status });
-                }
-                return undefined;
-            });
+        delete: async (init, options) => {
+            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) => {
-            return this.createStub('file', 'deleteBulk', () => {
-                const status = options?.status ?? 204;
-                if (status !== 204) {
-                    throw new Exception('Mocked error', { status });
-                }
-                return undefined;
-            });
+        deleteBulk: async (init, options) => {
+            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) => {
-            return this.createStub('file', 'patchUsers', () => {
-                const defaultData = this.generateFile();
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
+        patchUsers: async (init, options) => {
+            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) => {
-            return this.createStub('file', 'addUser', () => {
-                const defaultData = this.generateFile();
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
+        addUser: async (init, options) => {
+            await this.file.patchUsers(init, options);
         },
         /**
          * Mocks the `file.removeUser()` method.
          */
-        removeUser: (options) => {
-            return this.createStub('file', 'removeUser', () => {
-                const defaultData = this.generateFile();
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
+        removeUser: async (init, options) => {
+            await this.file.patchUsers(init, options);
         },
         /**
          * Mocks the `file.listUsers()` method.
          */
-        listUsers: (options) => {
-            return this.createStub('file', 'listUsers', () => {
-                const defaultData = {
-                    items: [this.generateUser(), this.generateUser()],
+        listUsers: async (init, options) => {
+            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 = {
+                    items: this.gen.user.users(init?.size ?? 5),
+                    cursor: this.createCursorOption(init),
                 };
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
+                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) => {
-            return this.createStub('file', 'breadcrumbs', () => {
-                const defaultData = {
-                    items: this.generateBreadcrumbs(),
+        breadcrumbs: async (init, options) => {
+            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 = {
+                    items: this.gen.file.fileBreadcrumbs(init?.size ?? 5),
+                    cursor: this.createCursorOption(init),
                 };
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
+                return JSON.stringify(obj);
+            }, init);
+            await mock.add({
+                match: {
+                    uri: RouteBuilder.fileBreadcrumbs(':oid', ':id'),
+                    methods: ['GET'],
+                },
+                respond,
+            }, options);
         },
     };
     /**
      * Shared API mocks.
      */
     shared = {
-        list: (options) => {
-            return this.createStub('shared', 'list', () => {
-                const defaultData = {
-                    items: [this.generateFile(), this.generateFile()],
+        list: async (init, options) => {
+            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 = {
+                    items: this.gen.file.files(init?.size ?? 5),
+                    cursor: this.createCursorOption(init),
                 };
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
+                return JSON.stringify(obj);
+            }, init);
+            await mock.add({
+                match: {
+                    uri: RouteBuilder.shared(':oid'),
+                    methods: ['GET'],
+                },
+                respond,
+            }, options);
         },
     };
     /**
      * Trash API mocks.
      */
     trash = {
-        list: (options) => {
-            return this.createStub('trash', 'list', () => {
-                const defaultData = {
-                    items: [this.generateTrashEntry(), this.generateTrashEntry()],
+        list: async (init, options) => {
+            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 = {
+                    items: this.gen.trash.trashEntries(init?.size ?? 5),
+                    cursor: this.createCursorOption(init),
                 };
-                if (options?.status !== undefined && options.status !== 200) {
-                    throw new Exception('Mocked error', { status: options.status });
-                }
-                return (options?.data ?? defaultData);
-            });
-        },
-        delete: (options) => {
-            return this.createStub('trash', 'delete', () => {
-                const status = options?.status ?? 204;
-                if (status !== 204) {
-                    throw new Exception('Mocked error', { status });
-                }
-                return undefined;
-            });
-        },
-        restore: (options) => {
-            return this.createStub('trash', 'restore', () => {
-                const status = options?.status ?? 204;
-                if (status !== 204) {
-                    throw new Exception('Mocked error', { status });
-                }
-                return undefined;
-            });
-        },
-        empty: (options) => {
-            return this.createStub('trash', 'empty', () => {
-                const status = options?.status ?? 204;
-                if (status !== 204) {
-                    throw new Exception('Mocked error', { status });
-                }
-                return undefined;
-            });
+                return JSON.stringify(obj);
+            }, init);
+            await mock.add({
+                match: {
+                    uri: RouteBuilder.trash(':oid'),
+                    methods: ['GET'],
+                },
+                respond,
+            }, options);
+        },
+        delete: async (init, options) => {
+            const { mock } = this;
+            // const respond = init?.response ?? {
+            //   status: 204,
+            // }
+            const respond = this.createDefaultResponse(204, undefined, undefined, init);
+            await mock.add({
+                match: {
+                    uri: RouteBuilder.trashBatchDelete(':oid'),
+                    methods: ['DELETE'],
+                },
+                respond,
+            }, options);
+        },
+        restore: async (init, options) => {
+            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, options) => {
+            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);
         },
     };
-    /**
-     * Restores all stubs created by this mocker.
-     */
-    restore() {
-        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.
-     */
-    createStub(api, method, implementation) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let target = 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 = {
-            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.
-     */
-    generateOrganization() {
-        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']),
-        };
-    }
-    /**
-     * Generates a random group object.
-     */
-    generateGroup() {
-        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.
-     */
-    generateUser() {
-        const firstName = this.randomString();
-        const lastName = this.randomString();
-        return {
-            kind: UserKind,
-            key: nanoid(),
-            name: `${firstName} ${lastName}`,
-            email: [
-                {
-                    email: `${firstName.toLowerCase()}.${lastName.toLowerCase()}@example.com`,
-                    verified: true,
-                },
-            ],
-            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.
-     */
-    generateFile() {
-        const kind = this.randomChoice([ProjectKind, DomainFileKind, CertificateFileKind, FolderKind]);
-        const name = `File ${this.randomString()}`;
-        return File.createSchema({ kind, info: { name } });
-    }
-    /**
-     * Generates a random folder meta object.
-     */
-    generateFolder() {
-        const file = File.createSchema({ kind: FolderKind, info: { name: `Folder ${this.randomString()}` } });
-        return file;
-    }
-    /**
-     * Generates a random media patch revision object.
-     */
-    generateMediaPatchRevision() {
-        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.
-     */
-    generateBreadcrumbs() {
-        const depth = 2 + Math.floor(Math.random() * 2); // 2-3
-        const items = [];
-        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.
-     */
-    generateInvitation() {
-        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']),
-            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.
-     */
-    generateTrashEntry() {
-        return {
-            key: nanoid(),
-            refKey: nanoid(),
-            kind: this.randomChoice([ProjectKind, DomainFileKind, CertificateFileKind, FolderKind]),
-            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.
-     */
-    randomString() {
-        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.
-     */
-    randomChoice(choices) {
-        return choices[Math.floor(Math.random() * choices.length)];
-    }
-    /**
-     * Generates a random hex color.
-     */
-    randomColor() {
-        return `#${Math.floor(Math.random() * 16777215)
-            .toString(16)
-            .padStart(6, '0')}`;
-    }
 }
 //# sourceMappingURL=SdkMock.js.map