@workos-inc/node 3.0.0-user-management.1 → 3.0.0

package/lib/audit-logs/audit-logs.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuditLogs = void 0;
+const serializers_1 = require("./serializers");
 class AuditLogs {
     constructor(workos) {
         this.workos = workos;
@@ -17,21 +18,21 @@ class AuditLogs {
     createEvent(organization, event, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.workos.post('/audit_logs/events', {
-                event,
+                event: (0, serializers_1.serializeCreateAuditLogEventOptions)(event),
                 organization_id: organization,
             }, options);
         });
     }
     createExport(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.workos.post('/audit_logs/exports', options);
-            return data;
+            const { data } = yield this.workos.post('/audit_logs/exports', (0, serializers_1.serializeAuditLogExportOptions)(options));
+            return (0, serializers_1.deserializeAuditLogExport)(data);
         });
     }
     getExport(auditLogExportId) {
         return __awaiter(this, void 0, void 0, function* () {
             const { data } = yield this.workos.get(`/audit_logs/exports/${auditLogExportId}`);
-            return data;
+            return (0, serializers_1.deserializeAuditLogExport)(data);
         });
     }
 }

package/lib/audit-logs/audit-logs.spec.js

@@ -8,30 +8,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const axios_1 = __importDefault(require("axios"));
-const axios_mock_adapter_1 = __importDefault(require("axios-mock-adapter"));
+const axios_1 = require("axios");
 const exceptions_1 = require("../common/exceptions");
 const bad_request_exception_1 = require("../common/exceptions/bad-request.exception");
+const workos_mock_response_1 = require("../common/utils/workos-mock-response");
 const workos_1 = require("../workos");
-const mock = new axios_mock_adapter_1.default(axios_1.default);
+const serializers_1 = require("./serializers");
 const event = {
     action: 'document.updated',
-    occurred_at: new Date(),
+    occurredAt: new Date(),
     actor: {
         id: 'user_1',
         name: 'Jon Smith',
@@ -44,94 +30,91 @@ const event = {
         },
     ],
     context: {
-        location: ' 192.0.0.8',
-        user_agent: 'Firefox',
+        location: '192.0.0.8',
+        userAgent: 'Firefox',
     },
     metadata: {
         successful: true,
     },
 };
-const serializeEventOptions = (options) => (Object.assign(Object.assign({}, options), { occurred_at: options.occurred_at.toISOString() }));
 describe('AuditLogs', () => {
     describe('createEvent', () => {
         describe('with an idempotency key', () => {
             it('includes an idempotency key with request', () => __awaiter(void 0, void 0, void 0, function* () {
-                var _a;
-                mock
-                    .onPost('/audit_logs/events', {
-                    event: serializeEventOptions(event),
-                    organization_id: 'org_123',
-                })
-                    .replyOnce(201, { success: true });
+                const workosSpy = jest.spyOn(workos_1.WorkOS.prototype, 'post');
+                workosSpy.mockResolvedValueOnce((0, workos_mock_response_1.mockWorkOsResponse)(201, { success: true }));
                 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
                 yield expect(workos.auditLogs.createEvent('org_123', event, {
                     idempotencyKey: 'the-idempotency-key',
                 })).resolves.toBeUndefined();
-                expect((_a = mock.history.post[0].headers) === null || _a === void 0 ? void 0 : _a['Idempotency-Key']).toEqual('the-idempotency-key');
+                expect(workosSpy).toHaveBeenCalledWith('/audit_logs/events', {
+                    event: (0, serializers_1.serializeCreateAuditLogEventOptions)(event),
+                    organization_id: 'org_123',
+                }, { idempotencyKey: 'the-idempotency-key' });
             }));
         });
         describe('when the api responds with a 200', () => {
             it('returns void', () => __awaiter(void 0, void 0, void 0, function* () {
-                mock
-                    .onPost('/audit_logs/events', {
-                    organization_id: 'org_123',
-                    event: serializeEventOptions(event),
-                })
-                    .replyOnce(201, { success: true });
+                const workosSpy = jest.spyOn(workos_1.WorkOS.prototype, 'post');
+                workosSpy.mockResolvedValueOnce((0, workos_mock_response_1.mockWorkOsResponse)(201, { success: true }));
                 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
                 yield expect(workos.auditLogs.createEvent('org_123', event)).resolves.toBeUndefined();
+                expect(workosSpy).toHaveBeenCalledWith('/audit_logs/events', {
+                    event: (0, serializers_1.serializeCreateAuditLogEventOptions)(event),
+                    organization_id: 'org_123',
+                }, {});
             }));
         });
         describe('when the api responds with a 401', () => {
             it('throws an UnauthorizedException', () => __awaiter(void 0, void 0, void 0, function* () {
-                mock
-                    .onPost('/audit_logs/events', {
-                    organization_id: 'org_123',
-                    event: serializeEventOptions(event),
-                })
-                    .replyOnce(401, {
-                    message: 'Unauthorized',
-                }, { 'X-Request-ID': 'a-request-id' });
+                const workosSpy = jest.spyOn(workos_1.WorkOS.prototype, 'post');
+                workosSpy.mockImplementationOnce(() => {
+                    throw new axios_1.AxiosError('Could not authorize the request. Maybe your API key is invalid?', '401');
+                });
                 const workos = new workos_1.WorkOS('invalid apikey');
-                yield expect(workos.auditLogs.createEvent('org_123', event)).rejects.toStrictEqual(new exceptions_1.UnauthorizedException('a-request-id'));
+                yield expect(workos.auditLogs.createEvent('org_123', event)).rejects.toThrowError(new exceptions_1.UnauthorizedException('a-request-id'));
             }));
         });
         describe('when the api responds with a 400', () => {
             it('throws an BadRequestException', () => __awaiter(void 0, void 0, void 0, function* () {
+                const workosSpy = jest.spyOn(workos_1.WorkOS.prototype, 'post');
                 const errors = [
                     {
                         field: 'occurred_at',
                         code: 'occurred_at must be an ISO 8601 date string',
                     },
                 ];
-                mock
-                    .onPost('/audit_logs/events', {
-                    organization_id: 'org_123',
-                    event: serializeEventOptions(event),
-                })
-                    .replyOnce(400, {
-                    message: 'Audit Log could not be processed due to missing or incorrect data.',
-                    code: 'invalid_audit_log',
-                    errors,
-                }, { 'X-Request-ID': 'a-request-id' });
+                workosSpy.mockImplementationOnce(() => {
+                    throw new bad_request_exception_1.BadRequestException({
+                        code: '400',
+                        errors,
+                        message: 'Audit Log could not be processed due to missing or incorrect data.',
+                        requestID: 'a-request-id',
+                    });
+                });
                 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
                 yield expect(workos.auditLogs.createEvent('org_123', event)).rejects.toThrow(bad_request_exception_1.BadRequestException);
             }));
         });
     });
     describe('createExport', () => {
-        const serializeExportOptions = (_a) => {
-            var { range_end, range_start } = _a, options = __rest(_a, ["range_end", "range_start"]);
-            return (Object.assign({ range_start: range_start.toISOString(), range_end: range_end.toISOString() }, options));
-        };
         describe('when the api responds with a 201', () => {
             it('returns `audit_log_export`', () => __awaiter(void 0, void 0, void 0, function* () {
+                const workosSpy = jest.spyOn(workos_1.WorkOS.prototype, 'post');
                 const options = {
-                    organization_id: 'org_123',
-                    range_start: new Date(),
-                    range_end: new Date(),
+                    organizationId: 'org_123',
+                    rangeStart: new Date(),
+                    rangeEnd: new Date(),
                 };
                 const auditLogExport = {
+                    object: 'audit_log_export',
+                    id: 'audit_log_export_1234',
+                    state: 'pending',
+                    url: undefined,
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                };
+                const auditLogExportResponse = {
                     object: 'audit_log_export',
                     id: 'audit_log_export_1234',
                     state: 'pending',
@@ -139,26 +122,34 @@ describe('AuditLogs', () => {
                     created_at: new Date().toISOString(),
                     updated_at: new Date().toISOString(),
                 };
-                mock
-                    .onPost('/audit_logs/exports', serializeExportOptions(options))
-                    .replyOnce(201, auditLogExport);
+                workosSpy.mockResolvedValueOnce((0, workos_mock_response_1.mockWorkOsResponse)(201, auditLogExportResponse));
                 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
                 yield expect(workos.auditLogs.createExport(options)).resolves.toEqual(auditLogExport);
+                expect(workosSpy).toHaveBeenCalledWith('/audit_logs/exports', (0, serializers_1.serializeAuditLogExportOptions)(options));
             }));
         });
         describe('when additional filters are defined', () => {
             it('returns `audit_log_export`', () => __awaiter(void 0, void 0, void 0, function* () {
+                const workosSpy = jest.spyOn(workos_1.WorkOS.prototype, 'post');
                 const options = {
                     actions: ['foo', 'bar'],
                     actors: ['Jon', 'Smith'],
-                    actor_names: ['Jon', 'Smith'],
-                    actor_ids: ['user_foo', 'user_bar'],
-                    organization_id: 'org_123',
-                    range_end: new Date(),
-                    range_start: new Date(),
+                    actorNames: ['Jon', 'Smith'],
+                    actorIds: ['user_foo', 'user_bar'],
+                    organizationId: 'org_123',
+                    rangeEnd: new Date(),
+                    rangeStart: new Date(),
                     targets: ['user', 'team'],
                 };
                 const auditLogExport = {
+                    object: 'audit_log_export',
+                    id: 'audit_log_export_1234',
+                    state: 'pending',
+                    url: undefined,
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                };
+                const auditLogExportResponse = {
                     object: 'audit_log_export',
                     id: 'audit_log_export_1234',
                     state: 'pending',
@@ -166,34 +157,41 @@ describe('AuditLogs', () => {
                     created_at: new Date().toISOString(),
                     updated_at: new Date().toISOString(),
                 };
-                mock
-                    .onPost('/audit_logs/exports', serializeExportOptions(options))
-                    .replyOnce(201, auditLogExport);
+                workosSpy.mockResolvedValueOnce((0, workos_mock_response_1.mockWorkOsResponse)(201, auditLogExportResponse));
                 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
                 yield expect(workos.auditLogs.createExport(options)).resolves.toEqual(auditLogExport);
+                expect(workosSpy).toHaveBeenCalledWith('/audit_logs/exports', (0, serializers_1.serializeAuditLogExportOptions)(options));
             }));
         });
         describe('when the api responds with a 401', () => {
             it('throws an UnauthorizedException', () => __awaiter(void 0, void 0, void 0, function* () {
+                const workosSpy = jest.spyOn(workos_1.WorkOS.prototype, 'post');
                 const options = {
-                    organization_id: 'org_123',
-                    range_start: new Date(),
-                    range_end: new Date(),
+                    organizationId: 'org_123',
+                    rangeStart: new Date(),
+                    rangeEnd: new Date(),
                 };
-                mock
-                    .onPost('/audit_logs/exports', serializeExportOptions(options))
-                    .replyOnce(401, {
-                    message: 'Unauthorized',
-                }, { 'X-Request-ID': 'a-request-id' });
+                workosSpy.mockImplementationOnce(() => {
+                    throw new axios_1.AxiosError('Could not authorize the request. Maybe your API key is invalid?', '401');
+                });
                 const workos = new workos_1.WorkOS('invalid apikey');
-                yield expect(workos.auditLogs.createExport(options)).rejects.toStrictEqual(new exceptions_1.UnauthorizedException('a-request-id'));
+                yield expect(workos.auditLogs.createExport(options)).rejects.toThrowError(new exceptions_1.UnauthorizedException('a-request-id'));
             }));
         });
     });
     describe('getExport', () => {
         describe('when the api responds with a 201', () => {
             it('returns `audit_log_export`', () => __awaiter(void 0, void 0, void 0, function* () {
+                const workosSpy = jest.spyOn(workos_1.WorkOS.prototype, 'get');
                 const auditLogExport = {
+                    object: 'audit_log_export',
+                    id: 'audit_log_export_1234',
+                    state: 'pending',
+                    url: undefined,
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                };
+                const auditLogExportResponse = {
                     object: 'audit_log_export',
                     id: 'audit_log_export_1234',
                     state: 'pending',
@@ -201,20 +199,21 @@ describe('AuditLogs', () => {
                     created_at: new Date().toISOString(),
                     updated_at: new Date().toISOString(),
                 };
-                mock
-                    .onGet(`/audit_logs/exports/${auditLogExport.id}`)
-                    .replyOnce(200, auditLogExport);
+                workosSpy.mockResolvedValueOnce((0, workos_mock_response_1.mockWorkOsResponse)(201, auditLogExportResponse));
                 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
                 yield expect(workos.auditLogs.getExport(auditLogExport.id)).resolves.toEqual(auditLogExport);
+                expect(workosSpy).toHaveBeenCalledWith(`/audit_logs/exports/${auditLogExport.id}`);
             }));
         });
         describe('when the api responds with a 401', () => {
             it('throws an UnauthorizedException', () => __awaiter(void 0, void 0, void 0, function* () {
-                mock.onGet('/audit_logs/exports/audit_log_export_1234').replyOnce(401, {
-                    message: 'Unauthorized',
-                }, { 'X-Request-ID': 'a-request-id' });
+                const workosSpy = jest.spyOn(workos_1.WorkOS.prototype, 'get');
+                workosSpy.mockImplementationOnce(() => {
+                    throw new axios_1.AxiosError('Could not authorize the request. Maybe your API key is invalid?', '401');
+                });
                 const workos = new workos_1.WorkOS('invalid apikey');
-                yield expect(workos.auditLogs.getExport('audit_log_export_1234')).rejects.toStrictEqual(new exceptions_1.UnauthorizedException('a-request-id'));
+                yield expect(workos.auditLogs.getExport('audit_log_export_1234')).rejects.toThrowError(new exceptions_1.UnauthorizedException('a-request-id'));
+                expect(workosSpy).toHaveBeenCalledWith(`/audit_logs/exports/audit_log_export_1234`);
             }));
         });
     });

package/lib/audit-logs/interfaces/audit-log-export-options.interface.d.ts

@@ -1,13 +1,23 @@
 export interface AuditLogExportOptions {
     actions?: string[];
     /**
-     * @deprecated Please use `actor_names` instead.
+     * @deprecated Please use `actorNames` instead.
      */
     actors?: string[];
+    actorNames?: string[];
+    actorIds?: string[];
+    organizationId: string;
+    rangeEnd: Date;
+    rangeStart: Date;
+    targets?: string[];
+}
+export interface SerializedAuditLogExportOptions {
+    actions?: string[];
+    actors?: string[];
     actor_names?: string[];
     actor_ids?: string[];
     organization_id: string;
-    range_end: Date;
-    range_start: Date;
+    range_end: string;
+    range_start: string;
     targets?: string[];
 }

package/lib/audit-logs/interfaces/audit-log-export.interface.d.ts

@@ -1,4 +1,12 @@
 export interface AuditLogExport {
+    object: 'audit_log_export';
+    id: string;
+    state: 'pending' | 'ready' | 'error';
+    url?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AuditLogExportResponse {
     object: 'audit_log_export';
     id: string;
     state: 'pending' | 'ready' | 'error';

package/lib/audit-logs/interfaces/create-audit-log-event-options.interface.d.ts

@@ -14,7 +14,19 @@ export interface AuditLogTarget {
 export interface CreateAuditLogEventOptions {
     action: string;
     version?: number;
-    occurred_at: Date;
+    occurredAt: Date;
+    actor: AuditLogActor;
+    targets: AuditLogTarget[];
+    context: {
+        location: string;
+        userAgent?: string;
+    };
+    metadata?: Record<string, string | number | boolean>;
+}
+export interface SerializedCreateAuditLogEventOptions {
+    action: string;
+    version?: number;
+    occurred_at: string;
     actor: AuditLogActor;
     targets: AuditLogTarget[];
     context: {

package/lib/audit-logs/serializers/audit-log-export-options.serializer.d.ts

@@ -0,0 +1,2 @@
+import { AuditLogExportOptions, SerializedAuditLogExportOptions } from '../interfaces';
+export declare const serializeAuditLogExportOptions: (options: AuditLogExportOptions) => SerializedAuditLogExportOptions;

package/lib/audit-logs/serializers/audit-log-export-options.serializer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeAuditLogExportOptions = void 0;
+const serializeAuditLogExportOptions = (options) => ({
+    actions: options.actions,
+    actors: options.actors,
+    actor_names: options.actorNames,
+    actor_ids: options.actorIds,
+    organization_id: options.organizationId,
+    range_end: options.rangeEnd.toISOString(),
+    range_start: options.rangeStart.toISOString(),
+    targets: options.targets,
+});
+exports.serializeAuditLogExportOptions = serializeAuditLogExportOptions;

package/lib/audit-logs/serializers/audit-log-export.serializer.d.ts

@@ -0,0 +1,2 @@
+import { AuditLogExport, AuditLogExportResponse } from '../interfaces';
+export declare const deserializeAuditLogExport: (auditLogExport: AuditLogExportResponse) => AuditLogExport;

package/lib/audit-logs/serializers/audit-log-export.serializer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeAuditLogExport = void 0;
+const deserializeAuditLogExport = (auditLogExport) => ({
+    object: auditLogExport.object,
+    id: auditLogExport.id,
+    state: auditLogExport.state,
+    url: auditLogExport.url,
+    createdAt: auditLogExport.created_at,
+    updatedAt: auditLogExport.updated_at,
+});
+exports.deserializeAuditLogExport = deserializeAuditLogExport;

package/lib/audit-logs/serializers/create-audit-log-event-options.serializer.d.ts

@@ -0,0 +1,2 @@
+import { CreateAuditLogEventOptions, SerializedCreateAuditLogEventOptions } from '../interfaces';
+export declare const serializeCreateAuditLogEventOptions: (event: CreateAuditLogEventOptions) => SerializedCreateAuditLogEventOptions;

package/lib/audit-logs/serializers/create-audit-log-event-options.serializer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeCreateAuditLogEventOptions = void 0;
+const serializeCreateAuditLogEventOptions = (event) => ({
+    action: event.action,
+    version: event.version,
+    occurred_at: event.occurredAt.toISOString(),
+    actor: event.actor,
+    targets: event.targets,
+    context: {
+        location: event.context.location,
+        user_agent: event.context.userAgent,
+    },
+    metadata: event.metadata,
+});
+exports.serializeCreateAuditLogEventOptions = serializeCreateAuditLogEventOptions;

package/lib/audit-logs/serializers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './audit-log-export.serializer';
+export * from './audit-log-export-options.serializer';
+export * from './create-audit-log-event-options.serializer';

package/lib/audit-logs/serializers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./audit-log-export.serializer"), exports);
+__exportStar(require("./audit-log-export-options.serializer"), exports);
+__exportStar(require("./create-audit-log-event-options.serializer"), exports);

package/lib/audit-trail/audit-trail.d.ts

@@ -1,12 +1,12 @@
 import { CreateEventOptions } from './interfaces/create-event-options.interface';
 import { AuditTrailEvent } from './interfaces/event.interface';
 import { EventOptions } from './interfaces/event-options.interface';
-import { List } from '../common/interfaces/list.interface';
+import { ListResponse } from '../common/interfaces';
 import { ListEventsOptions } from './interfaces/list-events-options.interface';
 import { WorkOS } from '../workos';
 export declare class AuditTrail {
     private readonly workos;
     constructor(workos: WorkOS);
     createEvent(event: EventOptions, { idempotencyKey }?: CreateEventOptions): Promise<void>;
-    listEvents(options?: ListEventsOptions): Promise<List<AuditTrailEvent>>;
+    listEvents(options?: ListEventsOptions): Promise<ListResponse<AuditTrailEvent>>;
 }

package/lib/common/interfaces/at-least-one-property-of.interface.d.ts

@@ -0,0 +1,7 @@
+export type AtLeastOnePropertyOf<T> = {
+    [K in keyof T]: {
+        [L in K]: T[L];
+    } & {
+        [L in Exclude<keyof T, K>]?: T[L];
+    };
+}[keyof T];

package/lib/common/interfaces/event.interface.d.ts

@@ -0,0 +1,142 @@
+import { DirectoryUser, DirectoryUserResponse, EventDirectory, EventDirectoryGroup, EventDirectoryGroupResponse, EventDirectoryResponse } from '../../directory-sync/interfaces';
+import { Connection, ConnectionResponse } from '../../sso/interfaces';
+export interface EventBase {
+    id: string;
+    createdAt: string;
+}
+interface EventResponseBase {
+    id: string;
+    created_at: string;
+}
+export interface ConnectionActivatedEvent extends EventBase {
+    event: 'connection.activated';
+    data: Connection;
+}
+export interface ConnectionActivatedEventResponse extends EventResponseBase {
+    event: 'connection.activated';
+    data: ConnectionResponse;
+}
+export interface ConnectionDeactivatedEvent extends EventBase {
+    event: 'connection.deactivated';
+    data: Connection;
+}
+export interface ConnectionDeactivatedEventResponse extends EventResponseBase {
+    event: 'connection.deactivated';
+    data: ConnectionResponse;
+}
+export interface ConnectionDeletedEvent extends EventBase {
+    event: 'connection.deleted';
+    data: Connection;
+}
+export interface ConnectionDeletedEventResponse extends EventResponseBase {
+    event: 'connection.deleted';
+    data: ConnectionResponse;
+}
+export interface DsyncActivatedEvent extends EventBase {
+    event: 'dsync.activated';
+    data: EventDirectory;
+}
+export interface DsyncActivatedEventResponse extends EventResponseBase {
+    event: 'dsync.activated';
+    data: EventDirectoryResponse;
+}
+export interface DsyncDeactivatedEvent extends EventBase {
+    event: 'dsync.deactivated';
+    data: EventDirectory;
+}
+export interface DsyncDeactivatedEventResponse extends EventResponseBase {
+    event: 'dsync.deactivated';
+    data: EventDirectoryResponse;
+}
+export interface DsyncDeletedEvent extends EventBase {
+    event: 'dsync.deleted';
+    data: Omit<EventDirectory, 'domains' | 'externalKey'>;
+}
+export interface DsyncDeletedEventResponse extends EventResponseBase {
+    event: 'dsync.deleted';
+    data: Omit<EventDirectoryResponse, 'domains' | 'external_key'>;
+}
+export interface DsyncGroupCreatedEvent extends EventBase {
+    event: 'dsync.group.created';
+    data: EventDirectoryGroup;
+}
+export interface DsyncGroupCreatedEventResponse extends EventResponseBase {
+    event: 'dsync.group.created';
+    data: EventDirectoryGroupResponse;
+}
+export interface DsyncGroupDeletedEvent extends EventBase {
+    event: 'dsync.group.deleted';
+    data: EventDirectoryGroup;
+}
+export interface DsyncGroupDeletedEventResponse extends EventResponseBase {
+    event: 'dsync.group.deleted';
+    data: EventDirectoryGroupResponse;
+}
+export interface DsyncGroupUpdatedEvent extends EventBase {
+    event: 'dsync.group.updated';
+    data: EventDirectoryGroup & Record<'previousAttributes', any>;
+}
+export interface DsyncGroupUpdatedEventResponse extends EventResponseBase {
+    event: 'dsync.group.updated';
+    data: EventDirectoryGroupResponse & Record<'previous_attributes', any>;
+}
+export interface DsyncGroupUserAddedEvent extends EventBase {
+    event: 'dsync.group.user_added';
+    data: {
+        directoryId: string;
+        user: DirectoryUser;
+        group: Pick<EventDirectoryGroup, 'id' | 'name'>;
+    };
+}
+export interface DsyncGroupUserAddedEventResponse extends EventResponseBase {
+    event: 'dsync.group.user_added';
+    data: {
+        directory_id: string;
+        user: DirectoryUserResponse;
+        group: Pick<EventDirectoryGroupResponse, 'id' | 'name'>;
+    };
+}
+export interface DsyncGroupUserRemovedEvent extends EventBase {
+    event: 'dsync.group.user_removed';
+    data: {
+        directoryId: string;
+        user: DirectoryUser;
+        group: Pick<EventDirectoryGroup, 'id' | 'name'>;
+    };
+}
+export interface DsyncGroupUserRemovedEventResponse extends EventResponseBase {
+    event: 'dsync.group.user_removed';
+    data: {
+        directory_id: string;
+        user: DirectoryUserResponse;
+        group: Pick<EventDirectoryGroupResponse, 'id' | 'name'>;
+    };
+}
+export interface DsyncUserCreatedEvent extends EventBase {
+    event: 'dsync.user.created';
+    data: DirectoryUser;
+}
+export interface DsyncUserCreatedEventResponse extends EventResponseBase {
+    event: 'dsync.user.created';
+    data: DirectoryUserResponse;
+}
+export interface DsyncUserDeletedEvent extends EventBase {
+    event: 'dsync.user.deleted';
+    data: DirectoryUser;
+}
+export interface DsyncUserDeletedEventResponse extends EventResponseBase {
+    event: 'dsync.user.deleted';
+    data: DirectoryUserResponse;
+}
+export interface DsyncUserUpdatedEvent extends EventBase {
+    event: 'dsync.user.updated';
+    data: DirectoryUser & Record<'previousAttributes', any>;
+}
+export interface DsyncUserUpdatedEventResponse extends EventResponseBase {
+    event: 'dsync.user.updated';
+    data: DirectoryUserResponse & Record<'previous_attributes', any>;
+}
+export type Event = ConnectionActivatedEvent | ConnectionDeactivatedEvent | ConnectionDeletedEvent | DsyncActivatedEvent | DsyncDeactivatedEvent | DsyncDeletedEvent | DsyncGroupCreatedEvent | DsyncGroupUpdatedEvent | DsyncGroupDeletedEvent | DsyncGroupUserAddedEvent | DsyncGroupUserRemovedEvent | DsyncUserCreatedEvent | DsyncUserUpdatedEvent | DsyncUserDeletedEvent;
+export type EventResponse = ConnectionActivatedEventResponse | ConnectionDeactivatedEventResponse | ConnectionDeletedEventResponse | DsyncActivatedEventResponse | DsyncDeactivatedEventResponse | DsyncDeletedEventResponse | DsyncGroupCreatedEventResponse | DsyncGroupUpdatedEventResponse | DsyncGroupDeletedEventResponse | DsyncGroupUserAddedEventResponse | DsyncGroupUserRemovedEventResponse | DsyncUserCreatedEventResponse | DsyncUserUpdatedEventResponse | DsyncUserDeletedEventResponse;
+export type EventName = 'connection.activated' | 'connection.deactivated' | 'connection.deleted' | 'dsync.activated' | 'dsync.deactivated' | 'dsync.deleted' | 'dsync.group.created' | 'dsync.group.deleted' | 'dsync.group.updated' | 'dsync.group.user_added' | 'dsync.group.user_removed' | 'dsync.user.created' | 'dsync.user.deleted' | 'dsync.user.updated';
+export {};