@jmruthers/pace-core 0.5.68 → 0.5.70

package/src/types/__tests__/organisation.test.ts

@@ -0,0 +1,1133 @@
+/**
+ * @file Organisation Type Tests
+ * @package @jmruthers/pace-core
+ * @module Types/__tests__
+ * @since 1.0.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import type {
+  Organisation,
+  OrganisationUser,
+  OrganisationRole,
+  OrganisationPermission,
+  OrganisationSettings,
+  OrganisationInvitation,
+  OrganisationMembership,
+  OrganisationContext,
+  OrganisationProviderProps,
+  OrganisationHookReturn,
+  OrganisationEvent,
+  OrganisationTheme,
+  OrganisationConfig,
+  OrganisationLimits,
+  OrganisationBilling,
+  OrganisationSubscription,
+  OrganisationFeature,
+  OrganisationIntegration,
+  OrganisationWebhook,
+  OrganisationAuditLog,
+  OrganisationAnalytics
+} from '../organisation';
+
+describe('[types] Organisation Types', () => {
+  describe('Organisation interface', () => {
+    it('validates Organisation type structure', () => {
+      const organisation: Organisation = {
+        id: 'org-123',
+        name: 'Test Organisation',
+        slug: 'test-org',
+        description: 'A test organisation',
+        logo_url: 'https://example.com/logo.png',
+        website: 'https://example.com',
+        email: 'contact@example.com',
+        phone: '+1234567890',
+        address: {
+          street: '123 Main St',
+          city: 'Test City',
+          state: 'TS',
+          postal_code: '12345',
+          country: 'US'
+        },
+        settings: {
+          timezone: 'UTC',
+          date_format: 'YYYY-MM-DD',
+          currency: 'USD',
+          language: 'en'
+        },
+        limits: {
+          max_users: 100,
+          max_events: 50,
+          max_storage_gb: 10
+        },
+        features: ['analytics', 'custom_branding', 'api_access'],
+        status: 'active',
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+        created_by: 'user-123'
+      };
+
+      expect(organisation).toHaveProperty('id');
+      expect(organisation).toHaveProperty('name');
+      expect(organisation).toHaveProperty('slug');
+      expect(organisation).toHaveProperty('description');
+      expect(organisation).toHaveProperty('logo_url');
+      expect(organisation).toHaveProperty('website');
+      expect(organisation).toHaveProperty('email');
+      expect(organisation).toHaveProperty('phone');
+      expect(organisation).toHaveProperty('address');
+      expect(organisation).toHaveProperty('settings');
+      expect(organisation).toHaveProperty('limits');
+      expect(organisation).toHaveProperty('features');
+      expect(organisation).toHaveProperty('status');
+      expect(organisation).toHaveProperty('created_at');
+      expect(organisation).toHaveProperty('updated_at');
+      expect(organisation).toHaveProperty('created_by');
+
+      expect(typeof organisation.id).toBe('string');
+      expect(typeof organisation.name).toBe('string');
+      expect(typeof organisation.slug).toBe('string');
+      expect(typeof organisation.description).toBe('string');
+      expect(typeof organisation.logo_url).toBe('string');
+      expect(typeof organisation.website).toBe('string');
+      expect(typeof organisation.email).toBe('string');
+      expect(typeof organisation.phone).toBe('string');
+      expect(typeof organisation.address).toBe('object');
+      expect(typeof organisation.settings).toBe('object');
+      expect(typeof organisation.limits).toBe('object');
+      expect(Array.isArray(organisation.features)).toBe(true);
+      expect(typeof organisation.status).toBe('string');
+      expect(typeof organisation.created_at).toBe('string');
+      expect(typeof organisation.updated_at).toBe('string');
+      expect(typeof organisation.created_by).toBe('string');
+    });
+
+    it('validates Organisation with minimal required fields', () => {
+      const organisation: Organisation = {
+        id: 'org-123',
+        name: 'Test Organisation',
+        slug: 'test-org',
+        status: 'active',
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+        created_by: 'user-123'
+      };
+
+      expect(organisation).toHaveProperty('id');
+      expect(organisation).toHaveProperty('name');
+      expect(organisation).toHaveProperty('slug');
+      expect(organisation).toHaveProperty('status');
+      expect(organisation).toHaveProperty('created_at');
+      expect(organisation).toHaveProperty('updated_at');
+      expect(organisation).toHaveProperty('created_by');
+      expect(organisation.description).toBeUndefined();
+      expect(organisation.logo_url).toBeUndefined();
+      expect(organisation.website).toBeUndefined();
+      expect(organisation.email).toBeUndefined();
+      expect(organisation.phone).toBeUndefined();
+      expect(organisation.address).toBeUndefined();
+      expect(organisation.settings).toBeUndefined();
+      expect(organisation.limits).toBeUndefined();
+      expect(organisation.features).toBeUndefined();
+    });
+  });
+
+  describe('OrganisationUser interface', () => {
+    it('validates OrganisationUser type structure', () => {
+      const orgUser: OrganisationUser = {
+        id: 'user-123',
+        organisation_id: 'org-123',
+        user_id: 'auth-user-123',
+        email: 'user@example.com',
+        first_name: 'John',
+        last_name: 'Doe',
+        avatar_url: 'https://example.com/avatar.jpg',
+        role: 'admin',
+        permissions: ['read:users', 'create:events', 'manage:all'],
+        status: 'active',
+        last_login: '2024-01-01T00:00:00Z',
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+        invited_by: 'admin-123',
+        invited_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(orgUser).toHaveProperty('id');
+      expect(orgUser).toHaveProperty('organisation_id');
+      expect(orgUser).toHaveProperty('user_id');
+      expect(orgUser).toHaveProperty('email');
+      expect(orgUser).toHaveProperty('first_name');
+      expect(orgUser).toHaveProperty('last_name');
+      expect(orgUser).toHaveProperty('avatar_url');
+      expect(orgUser).toHaveProperty('role');
+      expect(orgUser).toHaveProperty('permissions');
+      expect(orgUser).toHaveProperty('status');
+      expect(orgUser).toHaveProperty('last_login');
+      expect(orgUser).toHaveProperty('created_at');
+      expect(orgUser).toHaveProperty('updated_at');
+      expect(orgUser).toHaveProperty('invited_by');
+      expect(orgUser).toHaveProperty('invited_at');
+
+      expect(typeof orgUser.id).toBe('string');
+      expect(typeof orgUser.organisation_id).toBe('string');
+      expect(typeof orgUser.user_id).toBe('string');
+      expect(typeof orgUser.email).toBe('string');
+      expect(typeof orgUser.first_name).toBe('string');
+      expect(typeof orgUser.last_name).toBe('string');
+      expect(typeof orgUser.avatar_url).toBe('string');
+      expect(typeof orgUser.role).toBe('string');
+      expect(Array.isArray(orgUser.permissions)).toBe(true);
+      expect(typeof orgUser.status).toBe('string');
+      expect(typeof orgUser.last_login).toBe('string');
+      expect(typeof orgUser.created_at).toBe('string');
+      expect(typeof orgUser.updated_at).toBe('string');
+      expect(typeof orgUser.invited_by).toBe('string');
+      expect(typeof orgUser.invited_at).toBe('string');
+    });
+  });
+
+  describe('OrganisationRole interface', () => {
+    it('validates OrganisationRole type structure', () => {
+      const role: OrganisationRole = {
+        id: 'role-123',
+        organisation_id: 'org-123',
+        name: 'Event Manager',
+        description: 'Manages events and content',
+        permissions: ['read:events', 'create:events', 'update:events', 'delete:events'],
+        is_system_role: false,
+        is_default: false,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+        created_by: 'admin-123'
+      };
+
+      expect(role).toHaveProperty('id');
+      expect(role).toHaveProperty('organisation_id');
+      expect(role).toHaveProperty('name');
+      expect(role).toHaveProperty('description');
+      expect(role).toHaveProperty('permissions');
+      expect(role).toHaveProperty('is_system_role');
+      expect(role).toHaveProperty('is_default');
+      expect(role).toHaveProperty('created_at');
+      expect(role).toHaveProperty('updated_at');
+      expect(role).toHaveProperty('created_by');
+
+      expect(typeof role.id).toBe('string');
+      expect(typeof role.organisation_id).toBe('string');
+      expect(typeof role.name).toBe('string');
+      expect(typeof role.description).toBe('string');
+      expect(Array.isArray(role.permissions)).toBe(true);
+      expect(typeof role.is_system_role).toBe('boolean');
+      expect(typeof role.is_default).toBe('boolean');
+      expect(typeof role.created_at).toBe('string');
+      expect(typeof role.updated_at).toBe('string');
+      expect(typeof role.created_by).toBe('string');
+    });
+  });
+
+  describe('OrganisationPermission interface', () => {
+    it('validates OrganisationPermission type structure', () => {
+      const permission: OrganisationPermission = {
+        id: 'perm-123',
+        organisation_id: 'org-123',
+        name: 'create:events',
+        description: 'Create new events',
+        resource: 'events',
+        action: 'create',
+        conditions: ['organisation_id = current_organisation_id()'],
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(permission).toHaveProperty('id');
+      expect(permission).toHaveProperty('organisation_id');
+      expect(permission).toHaveProperty('name');
+      expect(permission).toHaveProperty('description');
+      expect(permission).toHaveProperty('resource');
+      expect(permission).toHaveProperty('action');
+      expect(permission).toHaveProperty('conditions');
+      expect(permission).toHaveProperty('created_at');
+      expect(permission).toHaveProperty('updated_at');
+
+      expect(typeof permission.id).toBe('string');
+      expect(typeof permission.organisation_id).toBe('string');
+      expect(typeof permission.name).toBe('string');
+      expect(typeof permission.description).toBe('string');
+      expect(typeof permission.resource).toBe('string');
+      expect(typeof permission.action).toBe('string');
+      expect(Array.isArray(permission.conditions)).toBe(true);
+      expect(typeof permission.created_at).toBe('string');
+      expect(typeof permission.updated_at).toBe('string');
+    });
+  });
+
+  describe('OrganisationSettings interface', () => {
+    it('validates OrganisationSettings type structure', () => {
+      const settings: OrganisationSettings = {
+        timezone: 'UTC',
+        date_format: 'YYYY-MM-DD',
+        time_format: '24h',
+        currency: 'USD',
+        language: 'en',
+        theme: {
+          primary_color: '#0ea5e9',
+          secondary_color: '#64748b',
+          accent_color: '#ef4444'
+        },
+        notifications: {
+          email_enabled: true,
+          push_enabled: false,
+          sms_enabled: false
+        },
+        security: {
+          two_factor_required: false,
+          session_timeout: 3600,
+          password_policy: 'medium'
+        },
+        features: {
+          analytics_enabled: true,
+          custom_branding_enabled: false,
+          api_access_enabled: true
+        }
+      };
+
+      expect(settings).toHaveProperty('timezone');
+      expect(settings).toHaveProperty('date_format');
+      expect(settings).toHaveProperty('time_format');
+      expect(settings).toHaveProperty('currency');
+      expect(settings).toHaveProperty('language');
+      expect(settings).toHaveProperty('theme');
+      expect(settings).toHaveProperty('notifications');
+      expect(settings).toHaveProperty('security');
+      expect(settings).toHaveProperty('features');
+
+      expect(typeof settings.timezone).toBe('string');
+      expect(typeof settings.date_format).toBe('string');
+      expect(typeof settings.time_format).toBe('string');
+      expect(typeof settings.currency).toBe('string');
+      expect(typeof settings.language).toBe('string');
+      expect(typeof settings.theme).toBe('object');
+      expect(typeof settings.notifications).toBe('object');
+      expect(typeof settings.security).toBe('object');
+      expect(typeof settings.features).toBe('object');
+    });
+  });
+
+  describe('OrganisationInvitation interface', () => {
+    it('validates OrganisationInvitation type structure', () => {
+      const invitation: OrganisationInvitation = {
+        id: 'invite-123',
+        organisation_id: 'org-123',
+        email: 'newuser@example.com',
+        role: 'user',
+        permissions: ['read:events'],
+        status: 'pending',
+        token: 'invite-token-123',
+        expires_at: '2024-01-08T00:00:00Z',
+        invited_by: 'admin-123',
+        invited_at: '2024-01-01T00:00:00Z',
+        accepted_at: null,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(invitation).toHaveProperty('id');
+      expect(invitation).toHaveProperty('organisation_id');
+      expect(invitation).toHaveProperty('email');
+      expect(invitation).toHaveProperty('role');
+      expect(invitation).toHaveProperty('permissions');
+      expect(invitation).toHaveProperty('status');
+      expect(invitation).toHaveProperty('token');
+      expect(invitation).toHaveProperty('expires_at');
+      expect(invitation).toHaveProperty('invited_by');
+      expect(invitation).toHaveProperty('invited_at');
+      expect(invitation).toHaveProperty('accepted_at');
+      expect(invitation).toHaveProperty('created_at');
+      expect(invitation).toHaveProperty('updated_at');
+
+      expect(typeof invitation.id).toBe('string');
+      expect(typeof invitation.organisation_id).toBe('string');
+      expect(typeof invitation.email).toBe('string');
+      expect(typeof invitation.role).toBe('string');
+      expect(Array.isArray(invitation.permissions)).toBe(true);
+      expect(typeof invitation.status).toBe('string');
+      expect(typeof invitation.token).toBe('string');
+      expect(typeof invitation.expires_at).toBe('string');
+      expect(typeof invitation.invited_by).toBe('string');
+      expect(typeof invitation.invited_at).toBe('string');
+      expect(invitation.accepted_at).toBeNull();
+      expect(typeof invitation.created_at).toBe('string');
+      expect(typeof invitation.updated_at).toBe('string');
+    });
+  });
+
+  describe('OrganisationMembership interface', () => {
+    it('validates OrganisationMembership type structure', () => {
+      const membership: OrganisationMembership = {
+        id: 'membership-123',
+        organisation_id: 'org-123',
+        user_id: 'user-123',
+        role: 'admin',
+        permissions: ['manage:all'],
+        status: 'active',
+        joined_at: '2024-01-01T00:00:00Z',
+        last_active: '2024-01-01T00:00:00Z',
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(membership).toHaveProperty('id');
+      expect(membership).toHaveProperty('organisation_id');
+      expect(membership).toHaveProperty('user_id');
+      expect(membership).toHaveProperty('role');
+      expect(membership).toHaveProperty('permissions');
+      expect(membership).toHaveProperty('status');
+      expect(membership).toHaveProperty('joined_at');
+      expect(membership).toHaveProperty('last_active');
+      expect(membership).toHaveProperty('created_at');
+      expect(membership).toHaveProperty('updated_at');
+
+      expect(typeof membership.id).toBe('string');
+      expect(typeof membership.organisation_id).toBe('string');
+      expect(typeof membership.user_id).toBe('string');
+      expect(typeof membership.role).toBe('string');
+      expect(Array.isArray(membership.permissions)).toBe(true);
+      expect(typeof membership.status).toBe('string');
+      expect(typeof membership.joined_at).toBe('string');
+      expect(typeof membership.last_active).toBe('string');
+      expect(typeof membership.created_at).toBe('string');
+      expect(typeof membership.updated_at).toBe('string');
+    });
+  });
+});
+
+describe('[types] Organisation Context Types', () => {
+  describe('OrganisationContext interface', () => {
+    it('validates OrganisationContext type structure', () => {
+      const context: OrganisationContext = {
+        organisation: {
+          id: 'org-123',
+          name: 'Test Organisation',
+          slug: 'test-org',
+          status: 'active',
+          created_at: '2024-01-01T00:00:00Z',
+          updated_at: '2024-01-01T00:00:00Z',
+          created_by: 'user-123'
+        },
+        user: {
+          id: 'user-123',
+          organisation_id: 'org-123',
+          user_id: 'auth-user-123',
+          email: 'user@example.com',
+          role: 'admin',
+          permissions: ['manage:all'],
+          status: 'active',
+          created_at: '2024-01-01T00:00:00Z',
+          updated_at: '2024-01-01T00:00:00Z'
+        },
+        permissions: ['manage:all'],
+        roles: ['admin'],
+        loading: false,
+        error: null,
+        switchOrganisation: () => {},
+        refreshOrganisation: () => {},
+        updateOrganisation: () => {},
+        inviteUser: () => {},
+        removeUser: () => {},
+        updateUserRole: () => {},
+        updateUserPermissions: () => {}
+      };
+
+      expect(context).toHaveProperty('organisation');
+      expect(context).toHaveProperty('user');
+      expect(context).toHaveProperty('permissions');
+      expect(context).toHaveProperty('roles');
+      expect(context).toHaveProperty('loading');
+      expect(context).toHaveProperty('error');
+      expect(context).toHaveProperty('switchOrganisation');
+      expect(context).toHaveProperty('refreshOrganisation');
+      expect(context).toHaveProperty('updateOrganisation');
+      expect(context).toHaveProperty('inviteUser');
+      expect(context).toHaveProperty('removeUser');
+      expect(context).toHaveProperty('updateUserRole');
+      expect(context).toHaveProperty('updateUserPermissions');
+
+      expect(typeof context.organisation).toBe('object');
+      expect(typeof context.user).toBe('object');
+      expect(Array.isArray(context.permissions)).toBe(true);
+      expect(Array.isArray(context.roles)).toBe(true);
+      expect(typeof context.loading).toBe('boolean');
+      expect(context.error).toBeNull();
+      expect(typeof context.switchOrganisation).toBe('function');
+      expect(typeof context.refreshOrganisation).toBe('function');
+      expect(typeof context.updateOrganisation).toBe('function');
+      expect(typeof context.inviteUser).toBe('function');
+      expect(typeof context.removeUser).toBe('function');
+      expect(typeof context.updateUserRole).toBe('function');
+      expect(typeof context.updateUserPermissions).toBe('function');
+    });
+  });
+
+  describe('OrganisationProviderProps interface', () => {
+    it('validates OrganisationProviderProps type structure', () => {
+      const props: OrganisationProviderProps = {
+        children: 'Test children',
+        organisationId: 'org-123',
+        userId: 'user-123',
+        autoRefresh: true,
+        refreshInterval: 30000,
+        onOrganisationChange: () => {},
+        onError: () => {}
+      };
+
+      expect(props).toHaveProperty('children');
+      expect(props).toHaveProperty('organisationId');
+      expect(props).toHaveProperty('userId');
+      expect(props).toHaveProperty('autoRefresh');
+      expect(props).toHaveProperty('refreshInterval');
+      expect(props).toHaveProperty('onOrganisationChange');
+      expect(props).toHaveProperty('onError');
+
+      expect(typeof props.children).toBe('string');
+      expect(typeof props.organisationId).toBe('string');
+      expect(typeof props.userId).toBe('string');
+      expect(typeof props.autoRefresh).toBe('boolean');
+      expect(typeof props.refreshInterval).toBe('number');
+      expect(typeof props.onOrganisationChange).toBe('function');
+      expect(typeof props.onError).toBe('function');
+    });
+  });
+
+  describe('OrganisationHookReturn interface', () => {
+    it('validates OrganisationHookReturn type structure', () => {
+      const hookReturn: OrganisationHookReturn = {
+        organisation: {
+          id: 'org-123',
+          name: 'Test Organisation',
+          slug: 'test-org',
+          status: 'active',
+          created_at: '2024-01-01T00:00:00Z',
+          updated_at: '2024-01-01T00:00:00Z',
+          created_by: 'user-123'
+        },
+        user: {
+          id: 'user-123',
+          organisation_id: 'org-123',
+          user_id: 'auth-user-123',
+          email: 'user@example.com',
+          role: 'admin',
+          permissions: ['manage:all'],
+          status: 'active',
+          created_at: '2024-01-01T00:00:00Z',
+          updated_at: '2024-01-01T00:00:00Z'
+        },
+        permissions: ['manage:all'],
+        roles: ['admin'],
+        loading: false,
+        error: null,
+        switchOrganisation: () => {},
+        refreshOrganisation: () => {},
+        updateOrganisation: () => {},
+        inviteUser: () => {},
+        removeUser: () => {},
+        updateUserRole: () => {},
+        updateUserPermissions: () => {},
+        hasPermission: () => true,
+        hasRole: () => true,
+        canAccess: () => true
+      };
+
+      expect(hookReturn).toHaveProperty('organisation');
+      expect(hookReturn).toHaveProperty('user');
+      expect(hookReturn).toHaveProperty('permissions');
+      expect(hookReturn).toHaveProperty('roles');
+      expect(hookReturn).toHaveProperty('loading');
+      expect(hookReturn).toHaveProperty('error');
+      expect(hookReturn).toHaveProperty('switchOrganisation');
+      expect(hookReturn).toHaveProperty('refreshOrganisation');
+      expect(hookReturn).toHaveProperty('updateOrganisation');
+      expect(hookReturn).toHaveProperty('inviteUser');
+      expect(hookReturn).toHaveProperty('removeUser');
+      expect(hookReturn).toHaveProperty('updateUserRole');
+      expect(hookReturn).toHaveProperty('updateUserPermissions');
+      expect(hookReturn).toHaveProperty('hasPermission');
+      expect(hookReturn).toHaveProperty('hasRole');
+      expect(hookReturn).toHaveProperty('canAccess');
+
+      expect(typeof hookReturn.organisation).toBe('object');
+      expect(typeof hookReturn.user).toBe('object');
+      expect(Array.isArray(hookReturn.permissions)).toBe(true);
+      expect(Array.isArray(hookReturn.roles)).toBe(true);
+      expect(typeof hookReturn.loading).toBe('boolean');
+      expect(hookReturn.error).toBeNull();
+      expect(typeof hookReturn.switchOrganisation).toBe('function');
+      expect(typeof hookReturn.refreshOrganisation).toBe('function');
+      expect(typeof hookReturn.updateOrganisation).toBe('function');
+      expect(typeof hookReturn.inviteUser).toBe('function');
+      expect(typeof hookReturn.removeUser).toBe('function');
+      expect(typeof hookReturn.updateUserRole).toBe('function');
+      expect(typeof hookReturn.updateUserPermissions).toBe('function');
+      expect(typeof hookReturn.hasPermission).toBe('function');
+      expect(typeof hookReturn.hasRole).toBe('function');
+      expect(typeof hookReturn.canAccess).toBe('function');
+    });
+  });
+});
+
+describe('[types] Organisation Extended Types', () => {
+  describe('OrganisationEvent interface', () => {
+    it('validates OrganisationEvent type structure', () => {
+      const orgEvent: OrganisationEvent = {
+        id: 'event-123',
+        organisation_id: 'org-123',
+        name: 'Test Event',
+        description: 'A test event',
+        start_date: '2024-01-01T00:00:00Z',
+        end_date: '2024-01-02T00:00:00Z',
+        status: 'active',
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(orgEvent).toHaveProperty('id');
+      expect(orgEvent).toHaveProperty('organisation_id');
+      expect(orgEvent).toHaveProperty('name');
+      expect(orgEvent).toHaveProperty('description');
+      expect(orgEvent).toHaveProperty('start_date');
+      expect(orgEvent).toHaveProperty('end_date');
+      expect(orgEvent).toHaveProperty('status');
+      expect(orgEvent).toHaveProperty('created_at');
+      expect(orgEvent).toHaveProperty('updated_at');
+
+      expect(typeof orgEvent.id).toBe('string');
+      expect(typeof orgEvent.organisation_id).toBe('string');
+      expect(typeof orgEvent.name).toBe('string');
+      expect(typeof orgEvent.description).toBe('string');
+      expect(typeof orgEvent.start_date).toBe('string');
+      expect(typeof orgEvent.end_date).toBe('string');
+      expect(typeof orgEvent.status).toBe('string');
+      expect(typeof orgEvent.created_at).toBe('string');
+      expect(typeof orgEvent.updated_at).toBe('string');
+    });
+  });
+
+  describe('OrganisationTheme interface', () => {
+    it('validates OrganisationTheme type structure', () => {
+      const theme: OrganisationTheme = {
+        id: 'theme-123',
+        organisation_id: 'org-123',
+        name: 'Custom Theme',
+        primary_color: '#0ea5e9',
+        secondary_color: '#64748b',
+        accent_color: '#ef4444',
+        background_color: '#ffffff',
+        text_color: '#000000',
+        is_default: false,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(theme).toHaveProperty('id');
+      expect(theme).toHaveProperty('organisation_id');
+      expect(theme).toHaveProperty('name');
+      expect(theme).toHaveProperty('primary_color');
+      expect(theme).toHaveProperty('secondary_color');
+      expect(theme).toHaveProperty('accent_color');
+      expect(theme).toHaveProperty('background_color');
+      expect(theme).toHaveProperty('text_color');
+      expect(theme).toHaveProperty('is_default');
+      expect(theme).toHaveProperty('created_at');
+      expect(theme).toHaveProperty('updated_at');
+
+      expect(typeof theme.id).toBe('string');
+      expect(typeof theme.organisation_id).toBe('string');
+      expect(typeof theme.name).toBe('string');
+      expect(typeof theme.primary_color).toBe('string');
+      expect(typeof theme.secondary_color).toBe('string');
+      expect(typeof theme.accent_color).toBe('string');
+      expect(typeof theme.background_color).toBe('string');
+      expect(typeof theme.text_color).toBe('string');
+      expect(typeof theme.is_default).toBe('boolean');
+      expect(typeof theme.created_at).toBe('string');
+      expect(typeof theme.updated_at).toBe('string');
+    });
+  });
+
+  describe('OrganisationConfig interface', () => {
+    it('validates OrganisationConfig type structure', () => {
+      const config: OrganisationConfig = {
+        id: 'config-123',
+        organisation_id: 'org-123',
+        key: 'feature_flags',
+        value: {
+          analytics_enabled: true,
+          custom_branding_enabled: false,
+          api_access_enabled: true
+        },
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(config).toHaveProperty('id');
+      expect(config).toHaveProperty('organisation_id');
+      expect(config).toHaveProperty('key');
+      expect(config).toHaveProperty('value');
+      expect(config).toHaveProperty('created_at');
+      expect(config).toHaveProperty('updated_at');
+
+      expect(typeof config.id).toBe('string');
+      expect(typeof config.organisation_id).toBe('string');
+      expect(typeof config.key).toBe('string');
+      expect(typeof config.value).toBe('object');
+      expect(typeof config.created_at).toBe('string');
+      expect(typeof config.updated_at).toBe('string');
+    });
+  });
+
+  describe('OrganisationLimits interface', () => {
+    it('validates OrganisationLimits type structure', () => {
+      const limits: OrganisationLimits = {
+        max_users: 100,
+        max_events: 50,
+        max_storage_gb: 10,
+        max_api_calls_per_month: 10000,
+        max_webhooks: 5,
+        max_integrations: 3,
+        max_custom_fields: 20,
+        max_roles: 10,
+        max_permissions: 50
+      };
+
+      expect(limits).toHaveProperty('max_users');
+      expect(limits).toHaveProperty('max_events');
+      expect(limits).toHaveProperty('max_storage_gb');
+      expect(limits).toHaveProperty('max_api_calls_per_month');
+      expect(limits).toHaveProperty('max_webhooks');
+      expect(limits).toHaveProperty('max_integrations');
+      expect(limits).toHaveProperty('max_custom_fields');
+      expect(limits).toHaveProperty('max_roles');
+      expect(limits).toHaveProperty('max_permissions');
+
+      expect(typeof limits.max_users).toBe('number');
+      expect(typeof limits.max_events).toBe('number');
+      expect(typeof limits.max_storage_gb).toBe('number');
+      expect(typeof limits.max_api_calls_per_month).toBe('number');
+      expect(typeof limits.max_webhooks).toBe('number');
+      expect(typeof limits.max_integrations).toBe('number');
+      expect(typeof limits.max_custom_fields).toBe('number');
+      expect(typeof limits.max_roles).toBe('number');
+      expect(typeof limits.max_permissions).toBe('number');
+    });
+  });
+
+  describe('OrganisationBilling interface', () => {
+    it('validates OrganisationBilling type structure', () => {
+      const billing: OrganisationBilling = {
+        id: 'billing-123',
+        organisation_id: 'org-123',
+        plan: 'pro',
+        status: 'active',
+        current_period_start: '2024-01-01T00:00:00Z',
+        current_period_end: '2024-02-01T00:00:00Z',
+        cancel_at_period_end: false,
+        trial_end: null,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(billing).toHaveProperty('id');
+      expect(billing).toHaveProperty('organisation_id');
+      expect(billing).toHaveProperty('plan');
+      expect(billing).toHaveProperty('status');
+      expect(billing).toHaveProperty('current_period_start');
+      expect(billing).toHaveProperty('current_period_end');
+      expect(billing).toHaveProperty('cancel_at_period_end');
+      expect(billing).toHaveProperty('trial_end');
+      expect(billing).toHaveProperty('created_at');
+      expect(billing).toHaveProperty('updated_at');
+
+      expect(typeof billing.id).toBe('string');
+      expect(typeof billing.organisation_id).toBe('string');
+      expect(typeof billing.plan).toBe('string');
+      expect(typeof billing.status).toBe('string');
+      expect(typeof billing.current_period_start).toBe('string');
+      expect(typeof billing.current_period_end).toBe('string');
+      expect(typeof billing.cancel_at_period_end).toBe('boolean');
+      expect(billing.trial_end).toBeNull();
+      expect(typeof billing.created_at).toBe('string');
+      expect(typeof billing.updated_at).toBe('string');
+    });
+  });
+
+  describe('OrganisationSubscription interface', () => {
+    it('validates OrganisationSubscription type structure', () => {
+      const subscription: OrganisationSubscription = {
+        id: 'sub-123',
+        organisation_id: 'org-123',
+        plan_id: 'plan-123',
+        status: 'active',
+        current_period_start: '2024-01-01T00:00:00Z',
+        current_period_end: '2024-02-01T00:00:00Z',
+        cancel_at_period_end: false,
+        trial_start: null,
+        trial_end: null,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(subscription).toHaveProperty('id');
+      expect(subscription).toHaveProperty('organisation_id');
+      expect(subscription).toHaveProperty('plan_id');
+      expect(subscription).toHaveProperty('status');
+      expect(subscription).toHaveProperty('current_period_start');
+      expect(subscription).toHaveProperty('current_period_end');
+      expect(subscription).toHaveProperty('cancel_at_period_end');
+      expect(subscription).toHaveProperty('trial_start');
+      expect(subscription).toHaveProperty('trial_end');
+      expect(subscription).toHaveProperty('created_at');
+      expect(subscription).toHaveProperty('updated_at');
+
+      expect(typeof subscription.id).toBe('string');
+      expect(typeof subscription.organisation_id).toBe('string');
+      expect(typeof subscription.plan_id).toBe('string');
+      expect(typeof subscription.status).toBe('string');
+      expect(typeof subscription.current_period_start).toBe('string');
+      expect(typeof subscription.current_period_end).toBe('string');
+      expect(typeof subscription.cancel_at_period_end).toBe('boolean');
+      expect(subscription.trial_start).toBeNull();
+      expect(subscription.trial_end).toBeNull();
+      expect(typeof subscription.created_at).toBe('string');
+      expect(typeof subscription.updated_at).toBe('string');
+    });
+  });
+
+  describe('OrganisationFeature interface', () => {
+    it('validates OrganisationFeature type structure', () => {
+      const feature: OrganisationFeature = {
+        id: 'feature-123',
+        organisation_id: 'org-123',
+        name: 'analytics',
+        enabled: true,
+        config: {
+          retention_days: 90,
+          track_events: true,
+          track_users: true
+        },
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(feature).toHaveProperty('id');
+      expect(feature).toHaveProperty('organisation_id');
+      expect(feature).toHaveProperty('name');
+      expect(feature).toHaveProperty('enabled');
+      expect(feature).toHaveProperty('config');
+      expect(feature).toHaveProperty('created_at');
+      expect(feature).toHaveProperty('updated_at');
+
+      expect(typeof feature.id).toBe('string');
+      expect(typeof feature.organisation_id).toBe('string');
+      expect(typeof feature.name).toBe('string');
+      expect(typeof feature.enabled).toBe('boolean');
+      expect(typeof feature.config).toBe('object');
+      expect(typeof feature.created_at).toBe('string');
+      expect(typeof feature.updated_at).toBe('string');
+    });
+  });
+
+  describe('OrganisationIntegration interface', () => {
+    it('validates OrganisationIntegration type structure', () => {
+      const integration: OrganisationIntegration = {
+        id: 'integration-123',
+        organisation_id: 'org-123',
+        name: 'Slack',
+        type: 'webhook',
+        config: {
+          webhook_url: 'https://hooks.slack.com/services/...',
+          channel: '#notifications',
+          events: ['user.created', 'event.updated']
+        },
+        status: 'active',
+        last_sync: '2024-01-01T00:00:00Z',
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(integration).toHaveProperty('id');
+      expect(integration).toHaveProperty('organisation_id');
+      expect(integration).toHaveProperty('name');
+      expect(integration).toHaveProperty('type');
+      expect(integration).toHaveProperty('config');
+      expect(integration).toHaveProperty('status');
+      expect(integration).toHaveProperty('last_sync');
+      expect(integration).toHaveProperty('created_at');
+      expect(integration).toHaveProperty('updated_at');
+
+      expect(typeof integration.id).toBe('string');
+      expect(typeof integration.organisation_id).toBe('string');
+      expect(typeof integration.name).toBe('string');
+      expect(typeof integration.type).toBe('string');
+      expect(typeof integration.config).toBe('object');
+      expect(typeof integration.status).toBe('string');
+      expect(typeof integration.last_sync).toBe('string');
+      expect(typeof integration.created_at).toBe('string');
+      expect(typeof integration.updated_at).toBe('string');
+    });
+  });
+
+  describe('OrganisationWebhook interface', () => {
+    it('validates OrganisationWebhook type structure', () => {
+      const webhook: OrganisationWebhook = {
+        id: 'webhook-123',
+        organisation_id: 'org-123',
+        url: 'https://example.com/webhook',
+        events: ['user.created', 'event.updated', 'organisation.updated'],
+        secret: 'webhook-secret-123',
+        status: 'active',
+        last_triggered: '2024-01-01T00:00:00Z',
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(webhook).toHaveProperty('id');
+      expect(webhook).toHaveProperty('organisation_id');
+      expect(webhook).toHaveProperty('url');
+      expect(webhook).toHaveProperty('events');
+      expect(webhook).toHaveProperty('secret');
+      expect(webhook).toHaveProperty('status');
+      expect(webhook).toHaveProperty('last_triggered');
+      expect(webhook).toHaveProperty('created_at');
+      expect(webhook).toHaveProperty('updated_at');
+
+      expect(typeof webhook.id).toBe('string');
+      expect(typeof webhook.organisation_id).toBe('string');
+      expect(typeof webhook.url).toBe('string');
+      expect(Array.isArray(webhook.events)).toBe(true);
+      expect(typeof webhook.secret).toBe('string');
+      expect(typeof webhook.status).toBe('string');
+      expect(typeof webhook.last_triggered).toBe('string');
+      expect(typeof webhook.created_at).toBe('string');
+      expect(typeof webhook.updated_at).toBe('string');
+    });
+  });
+
+  describe('OrganisationAuditLog interface', () => {
+    it('validates OrganisationAuditLog type structure', () => {
+      const auditLog: OrganisationAuditLog = {
+        id: 'audit-123',
+        organisation_id: 'org-123',
+        user_id: 'user-123',
+        action: 'user.created',
+        resource: 'users',
+        resource_id: 'user-456',
+        details: {
+          email: 'newuser@example.com',
+          role: 'user',
+          permissions: ['read:events']
+        },
+        ip_address: '192.168.1.1',
+        user_agent: 'Mozilla/5.0...',
+        created_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(auditLog).toHaveProperty('id');
+      expect(auditLog).toHaveProperty('organisation_id');
+      expect(auditLog).toHaveProperty('user_id');
+      expect(auditLog).toHaveProperty('action');
+      expect(auditLog).toHaveProperty('resource');
+      expect(auditLog).toHaveProperty('resource_id');
+      expect(auditLog).toHaveProperty('details');
+      expect(auditLog).toHaveProperty('ip_address');
+      expect(auditLog).toHaveProperty('user_agent');
+      expect(auditLog).toHaveProperty('created_at');
+
+      expect(typeof auditLog.id).toBe('string');
+      expect(typeof auditLog.organisation_id).toBe('string');
+      expect(typeof auditLog.user_id).toBe('string');
+      expect(typeof auditLog.action).toBe('string');
+      expect(typeof auditLog.resource).toBe('string');
+      expect(typeof auditLog.resource_id).toBe('string');
+      expect(typeof auditLog.details).toBe('object');
+      expect(typeof auditLog.ip_address).toBe('string');
+      expect(typeof auditLog.user_agent).toBe('string');
+      expect(typeof auditLog.created_at).toBe('string');
+    });
+  });
+
+  describe('OrganisationAnalytics interface', () => {
+    it('validates OrganisationAnalytics type structure', () => {
+      const analytics: OrganisationAnalytics = {
+        id: 'analytics-123',
+        organisation_id: 'org-123',
+        metric: 'user_count',
+        value: 150,
+        date: '2024-01-01',
+        metadata: {
+          source: 'database',
+          calculation_method: 'count'
+        },
+        created_at: '2024-01-01T00:00:00Z'
+      };
+
+      expect(analytics).toHaveProperty('id');
+      expect(analytics).toHaveProperty('organisation_id');
+      expect(analytics).toHaveProperty('metric');
+      expect(analytics).toHaveProperty('value');
+      expect(analytics).toHaveProperty('date');
+      expect(analytics).toHaveProperty('metadata');
+      expect(analytics).toHaveProperty('created_at');
+
+      expect(typeof analytics.id).toBe('string');
+      expect(typeof analytics.organisation_id).toBe('string');
+      expect(typeof analytics.metric).toBe('string');
+      expect(typeof analytics.value).toBe('number');
+      expect(typeof analytics.date).toBe('string');
+      expect(typeof analytics.metadata).toBe('object');
+      expect(typeof analytics.created_at).toBe('string');
+    });
+  });
+});
+
+describe('[types] Organisation Usage Patterns', () => {
+  describe('Organisation Management Operations', () => {
+    it('validates organisation management operation types', () => {
+      interface OrganisationManagementOperation {
+        operation: 'create' | 'update' | 'delete' | 'invite' | 'remove' | 'switch';
+        organisationId: string;
+        data?: Partial<Organisation>;
+        userId?: string;
+        role?: string;
+        permissions?: string[];
+      }
+
+      const operations: OrganisationManagementOperation[] = [
+        { operation: 'create', organisationId: 'org-123', data: { name: 'New Org' } },
+        { operation: 'update', organisationId: 'org-123', data: { name: 'Updated Org' } },
+        { operation: 'delete', organisationId: 'org-123' },
+        { operation: 'invite', organisationId: 'org-123', userId: 'user-123', role: 'user' },
+        { operation: 'remove', organisationId: 'org-123', userId: 'user-123' },
+        { operation: 'switch', organisationId: 'org-456' }
+      ];
+
+      operations.forEach(op => {
+        expect(op).toHaveProperty('operation');
+        expect(op).toHaveProperty('organisationId');
+        expect(['create', 'update', 'delete', 'invite', 'remove', 'switch']).toContain(op.operation);
+        expect(typeof op.organisationId).toBe('string');
+        if (op.data) {
+          expect(typeof op.data).toBe('object');
+        }
+        if (op.userId) {
+          expect(typeof op.userId).toBe('string');
+        }
+        if (op.role) {
+          expect(typeof op.role).toBe('string');
+        }
+        if (op.permissions) {
+          expect(Array.isArray(op.permissions)).toBe(true);
+        }
+      });
+    });
+  });
+
+  describe('Organisation Permission Checks', () => {
+    it('validates organisation permission check types', () => {
+      interface OrganisationPermissionCheck {
+        resource: string;
+        action: string;
+        organisationId: string;
+        userId: string;
+        context?: Record<string, any>;
+      }
+
+      const permissionChecks: OrganisationPermissionCheck[] = [
+        {
+          resource: 'users',
+          action: 'create',
+          organisationId: 'org-123',
+          userId: 'user-123'
+        },
+        {
+          resource: 'events',
+          action: 'update',
+          organisationId: 'org-123',
+          userId: 'user-123',
+          context: { eventId: 'event-456' }
+        }
+      ];
+
+      permissionChecks.forEach(check => {
+        expect(check).toHaveProperty('resource');
+        expect(check).toHaveProperty('action');
+        expect(check).toHaveProperty('organisationId');
+        expect(check).toHaveProperty('userId');
+        expect(typeof check.resource).toBe('string');
+        expect(typeof check.action).toBe('string');
+        expect(typeof check.organisationId).toBe('string');
+        expect(typeof check.userId).toBe('string');
+        if (check.context) {
+          expect(typeof check.context).toBe('object');
+        }
+      });
+    });
+  });
+
+  describe('Organisation Data Validation', () => {
+    it('validates organisation data validation types', () => {
+      interface OrganisationDataValidation {
+        field: keyof Organisation;
+        value: any;
+        rules: {
+          required?: boolean;
+          minLength?: number;
+          maxLength?: number;
+          pattern?: RegExp;
+          custom?: (value: any) => boolean;
+        };
+      }
+
+      const validations: OrganisationDataValidation[] = [
+        {
+          field: 'name',
+          value: 'Test Organisation',
+          rules: {
+            required: true,
+            minLength: 2,
+            maxLength: 100
+          }
+        },
+        {
+          field: 'email',
+          value: 'contact@example.com',
+          rules: {
+            required: false,
+            pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+          }
+        }
+      ];
+
+      validations.forEach(validation => {
+        expect(validation).toHaveProperty('field');
+        expect(validation).toHaveProperty('value');
+        expect(validation).toHaveProperty('rules');
+        expect(typeof validation.field).toBe('string');
+        expect(typeof validation.rules).toBe('object');
+        if (validation.rules.required !== undefined) {
+          expect(typeof validation.rules.required).toBe('boolean');
+        }
+        if (validation.rules.minLength !== undefined) {
+          expect(typeof validation.rules.minLength).toBe('number');
+        }
+        if (validation.rules.maxLength !== undefined) {
+          expect(typeof validation.rules.maxLength).toBe('number');
+        }
+        if (validation.rules.pattern !== undefined) {
+          expect(validation.rules.pattern).toBeInstanceOf(RegExp);
+        }
+        if (validation.rules.custom !== undefined) {
+          expect(typeof validation.rules.custom).toBe('function');
+        }
+      });
+    });
+  });
+});