@api-client/core 0.18.34 → 0.18.36

package/build/src/sdk/SdkMock.js

@@ -0,0 +1,850 @@
+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';
+/**
+ * SDK mocking utility for testing. Provides simple API to mock SDK calls
+ * with random or custom responses.
+ *
+ * @example
+ * ```typescript
+ * import { SdkMock } from '@api-client/core/sdk/SdkMock.js';
+ * import { StoreSdk } from '@api-client/core/sdk/StoreSdkWeb.js';
+ *
+ * const sdk = new StoreSdk('http://localhost:8080');
+ * const mocker = new SdkMock(sdk);
+ *
+ * // Simple usage - returns random valid organization
+ * const stub1 = mocker.organizations.list();
+ *
+ * // Custom response
+ * const stub2 = mocker.organizations.create({
+ *   data: { key: 'org-1', name: 'Test Org', ... }
+ * });
+ *
+ * // Custom status and headers
+ * const stub3 = mocker.users.me({
+ *   status: 404,
+ *   headers: { 'X-Custom': 'value' }
+ * });
+ *
+ * // Restore all stubs
+ * mocker.restore();
+ * ```
+ */
+export class SdkMock {
+    sdk;
+    stubs = [];
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * 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.
+         */
+        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);
+            });
+        },
+        /**
+         * Mocks the `organizations.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('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);
+            });
+        },
+        invitations: {
+            list: (options) => {
+                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);
+                });
+            },
+            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);
+                });
+            },
+            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);
+                });
+            },
+            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);
+                });
+            },
+            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);
+                });
+            },
+            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);
+                });
+            },
+            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);
+                });
+            },
+        },
+        users: {
+            list: (options) => {
+                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);
+                });
+            },
+            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);
+                });
+            },
+            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);
+                });
+            },
+            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);
+                });
+            },
+            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);
+                });
+            },
+            delete: (options) => {
+                return this.createStub('organizations.users', 'delete', () => {
+                    const status = options?.status ?? 204;
+                    if (status !== 204) {
+                        throw new Exception('Mocked error', { status });
+                    }
+                    return undefined;
+                });
+            },
+        },
+    };
+    /**
+     * Group API mocks.
+     */
+    groups = {
+        /**
+         * 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,
+                };
+                if (options?.status !== undefined && options.status !== 200) {
+                    throw new Exception('Mocked error', { status: options.status });
+                }
+                return (options?.data ?? defaultData);
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * 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;
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+    };
+    /**
+     * User API mocks.
+     */
+    users = {
+        /**
+         * 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 });
+                }
+                return (options?.data ?? defaultData);
+            });
+        },
+    };
+    /**
+     * Auth API mocks.
+     */
+    auth = {
+        /**
+         * Mocks the `auth.oauthRedirect()` method.
+         * This method returns `null` by default as it performs window navigation.
+         * @param options Optional response customization.
+         * @returns A stub reference that can be used to restore the original behavior.
+         */
+        oauthRedirect: (options) => {
+            return this.createStub('auth', 'oauthRedirect', () => {
+                const defaultData = options?.data ?? null;
+                return defaultData;
+            }, true);
+        },
+    };
+    /**
+     * Files API mocks.
+     */
+    file = {
+        /**
+         * Mocks the `file.list()` method.
+         */
+        list: (options) => {
+            return this.createStub('file', 'list', () => {
+                const defaultData = {
+                    items: [this.generateFile(), this.generateFile()],
+                };
+                if (options?.status !== undefined && options.status !== 200) {
+                    throw new Exception('Mocked error', { status: options.status });
+                }
+                return (options?.data ?? defaultData);
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * 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;
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * Mocks the `file.readBulk()` method.
+         */
+        readBulk: (options) => {
+            return this.createStub('file', 'readBulk', () => {
+                const defaultData = {
+                    items: [this.generateFile(), undefined],
+                };
+                if (options?.status !== undefined && options.status !== 200) {
+                    throw new Exception('Mocked error', { status: options.status });
+                }
+                return (options?.data ?? defaultData);
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * 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;
+            });
+        },
+        /**
+         * 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;
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * 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);
+            });
+        },
+        /**
+         * Mocks the `file.listUsers()` method.
+         */
+        listUsers: (options) => {
+            return this.createStub('file', 'listUsers', () => {
+                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);
+            });
+        },
+        /**
+         * Mocks the `file.breadcrumbs()` method.
+         */
+        breadcrumbs: (options) => {
+            return this.createStub('file', 'breadcrumbs', () => {
+                const defaultData = {
+                    items: this.generateBreadcrumbs(),
+                };
+                if (options?.status !== undefined && options.status !== 200) {
+                    throw new Exception('Mocked error', { status: options.status });
+                }
+                return (options?.data ?? defaultData);
+            });
+        },
+    };
+    /**
+     * Shared API mocks.
+     */
+    shared = {
+        list: (options) => {
+            return this.createStub('shared', 'list', () => {
+                const defaultData = {
+                    items: [this.generateFile(), this.generateFile()],
+                };
+                if (options?.status !== undefined && options.status !== 200) {
+                    throw new Exception('Mocked error', { status: options.status });
+                }
+                return (options?.data ?? defaultData);
+            });
+        },
+    };
+    /**
+     * Trash API mocks.
+     */
+    trash = {
+        list: (options) => {
+            return this.createStub('trash', 'list', () => {
+                const defaultData = {
+                    items: [this.generateTrashEntry(), this.generateTrashEntry()],
+                };
+                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;
+            });
+        },
+    };
+    /**
+     * 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, sync) {
+        // 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`);
+        }
+        // Store original and create stub using sinon
+        const stub = sync
+            ? sinon.stub(target, method).callsFake(() => implementation())
+            : 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;
+    }
+    /**
+     * Creates a response object from data and options.
+     * @param defaultData Default data to return if not overridden.
+     * @param options Response options.
+     * @returns The final data to return (for non-HTTP responses) or IStoreResponse (for HTTP responses).
+     */
+    createResponse(defaultData, options) {
+        // For SDK-level stubs we return plain data. Status and headers are
+        // accepted but not propagated, since high-level SDK methods return data.
+        const data = options?.data !== undefined ? options.data : defaultData;
+        return data;
+    }
+    /**
+     * 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