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

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 {};

package/lib/common/interfaces/index.d.ts

@@ -1,5 +1,10 @@
+export * from './at-least-one-property-of.interface';
+export * from './event.interface';
 export * from './get-options.interface';
+export * from './list.interface';
 export * from './post-options.interface';
 export * from './put-options.interface';
 export * from './unprocessable-entity-error.interface';
 export * from './workos-options.interface';
+export * from './workos-response-error.interface';
+export * from './pagination-options.interface';

package/lib/common/interfaces/index.js

@@ -14,8 +14,13 @@ 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("./at-least-one-property-of.interface"), exports);
+__exportStar(require("./event.interface"), exports);
 __exportStar(require("./get-options.interface"), exports);
+__exportStar(require("./list.interface"), exports);
 __exportStar(require("./post-options.interface"), exports);
 __exportStar(require("./put-options.interface"), exports);
 __exportStar(require("./unprocessable-entity-error.interface"), exports);
 __exportStar(require("./workos-options.interface"), exports);
+__exportStar(require("./workos-response-error.interface"), exports);
+__exportStar(require("./pagination-options.interface"), exports);

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

@@ -1,4 +1,4 @@
-export interface List<T> {
+export interface ListResponse<T> {
     readonly object: 'list';
     data: T[];
     list_metadata: {
@@ -6,3 +6,11 @@ export interface List<T> {
         after?: string;
     };
 }
+export interface List<T> {
+    readonly object: 'list';
+    data: T[];
+    listMetadata: {
+        before?: string;
+        after?: string;
+    };
+}

package/lib/common/interfaces/workos-response-error.interface.d.ts

@@ -0,0 +1,8 @@
+import { UnprocessableEntityError } from './unprocessable-entity-error.interface';
+export interface WorkOSResponseError {
+    code?: string;
+    error_description?: string;
+    error?: string;
+    errors?: UnprocessableEntityError[];
+    message: string;
+}

package/lib/common/serializers/event.serializer.d.ts

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

package/lib/common/serializers/event.serializer.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeEvent = void 0;
+const serializers_1 = require("../../directory-sync/serializers");
+const serializers_2 = require("../../sso/serializers");
+const deserializeEvent = (event) => {
+    const eventBase = {
+        id: event.id,
+        createdAt: event.created_at,
+    };
+    switch (event.event) {
+        case 'connection.activated':
+        case 'connection.deactivated':
+        case 'connection.deleted':
+            return Object.assign(Object.assign({}, eventBase), { event: event.event, data: (0, serializers_2.deserializeConnection)(event.data) });
+        case 'dsync.activated':
+        case 'dsync.deactivated':
+            return Object.assign(Object.assign({}, eventBase), { event: event.event, data: (0, serializers_1.deserializeEventDirectory)(event.data) });
+        case 'dsync.deleted':
+            return Object.assign(Object.assign({}, eventBase), { event: event.event, data: (0, serializers_1.deserializeDeletedEventDirectory)(event.data) });
+        case 'dsync.group.created':
+        case 'dsync.group.deleted':
+            return Object.assign(Object.assign({}, eventBase), { event: event.event, data: (0, serializers_1.deserializeEventDirectoryGroup)(event.data) });
+        case 'dsync.group.updated':
+            return Object.assign(Object.assign({}, eventBase), { event: event.event, data: (0, serializers_1.deserializeUpdatedEventDirectoryGroup)(event.data) });
+        case 'dsync.group.user_added':
+        case 'dsync.group.user_removed':
+            return Object.assign(Object.assign({}, eventBase), { event: event.event, data: {
+                    directoryId: event.data.directory_id,
+                    user: (0, serializers_1.deserializeDirectoryUser)(event.data.user),
+                    group: event.data.group,
+                } });
+        case 'dsync.user.created':
+        case 'dsync.user.deleted':
+            return Object.assign(Object.assign({}, eventBase), { event: event.event, data: (0, serializers_1.deserializeDirectoryUser)(event.data) });
+        case 'dsync.user.updated':
+            return Object.assign(Object.assign({}, eventBase), { event: event.event, data: (0, serializers_1.deserializeUpdatedEventDirectoryUser)(event.data) });
+    }
+};
+exports.deserializeEvent = deserializeEvent;

package/lib/common/serializers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './event.serializer';
+export * from './list.serializer';

package/lib/common/serializers/index.js

@@ -0,0 +1,18 @@
+"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("./event.serializer"), exports);
+__exportStar(require("./list.serializer"), exports);

package/lib/common/serializers/list.serializer.d.ts

@@ -0,0 +1,2 @@
+import { List, ListResponse } from '../interfaces';
+export declare const deserializeList: <TSerialized, TDeserialized>(list: ListResponse<TSerialized>, deserializer: (serialized: TSerialized) => TDeserialized) => List<TDeserialized>;

package/lib/common/serializers/list.serializer.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeList = void 0;
+const deserializeList = (list, deserializer) => ({
+    object: 'list',
+    data: list.data.map(deserializer),
+    listMetadata: list.list_metadata,
+});
+exports.deserializeList = deserializeList;

package/lib/common/utils/fetch-and-deserialize.d.ts

@@ -0,0 +1,3 @@
+import { WorkOS } from '../../workos';
+import { List, PaginationOptions } from '../interfaces';
+export declare const fetchAndDeserialize: <T, U>(workos: WorkOS, endpoint: string, deserializeFn: (data: T) => U, options?: PaginationOptions) => Promise<List<U>>;

package/lib/common/utils/fetch-and-deserialize.js

@@ -0,0 +1,23 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAndDeserialize = void 0;
+const serializers_1 = require("../serializers");
+const setDefaultOptions = (options) => {
+    return Object.assign(Object.assign({}, options), { order: (options === null || options === void 0 ? void 0 : options.order) || 'desc' });
+};
+const fetchAndDeserialize = (workos, endpoint, deserializeFn, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { data } = yield workos.get(endpoint, {
+        query: setDefaultOptions(options),
+    });
+    return (0, serializers_1.deserializeList)(data, deserializeFn);
+});
+exports.fetchAndDeserialize = fetchAndDeserialize;

package/lib/common/utils/pagination.d.ts

@@ -0,0 +1,15 @@
+import { List, PaginationOptions } from '../interfaces';
+export declare class AutoPaginatable<T> {
+    private list;
+    private apiCall;
+    readonly object: 'list';
+    readonly options: PaginationOptions;
+    constructor(list: List<T>, apiCall: (params: PaginationOptions) => Promise<List<T>>, options?: PaginationOptions);
+    get data(): T[];
+    get listMetadata(): {
+        before?: string | undefined;
+        after?: string | undefined;
+    };
+    private generatePages;
+    autoPagination(): Promise<T[]>;
+}

package/lib/common/utils/pagination.js

@@ -0,0 +1,90 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoPaginatable = void 0;
+class AutoPaginatable {
+    constructor(list, apiCall, options) {
+        this.list = list;
+        this.apiCall = apiCall;
+        this.object = 'list';
+        this.options = Object.assign({}, options);
+    }
+    get data() {
+        return this.list.data;
+    }
+    get listMetadata() {
+        return this.list.listMetadata;
+    }
+    generatePages(params) {
+        return __asyncGenerator(this, arguments, function* generatePages_1() {
+            const result = yield __await(this.apiCall(Object.assign(Object.assign({}, this.options), { after: params.after })));
+            yield yield __await(result.data);
+            if (result.listMetadata.after) {
+                yield __await(yield* __asyncDelegator(__asyncValues(this.generatePages({ after: result.listMetadata.after }))));
+            }
+        });
+    }
+    autoPagination() {
+        var _a, e_1, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.options.limit) {
+                const generatePages = this.generatePages({
+                    after: this.options.after,
+                });
+                const results = [];
+                try {
+                    for (var _d = true, generatePages_2 = __asyncValues(generatePages), generatePages_2_1; generatePages_2_1 = yield generatePages_2.next(), _a = generatePages_2_1.done, !_a; _d = true) {
+                        _c = generatePages_2_1.value;
+                        _d = false;
+                        const page = _c;
+                        results.push(...page);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = generatePages_2.return)) yield _b.call(generatePages_2);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                return results;
+            }
+            else {
+                return this.data;
+            }
+        });
+    }
+}
+exports.AutoPaginatable = AutoPaginatable;

package/lib/common/utils/workos-mock-response.d.ts

@@ -0,0 +1,7 @@
+export declare const mockWorkOsResponse: (status: number, data: unknown) => {
+    data: unknown;
+    status: number;
+    headers: {};
+    statusText: string;
+    config: any;
+};

package/lib/common/utils/workos-mock-response.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockWorkOsResponse = void 0;
+const mockWorkOsResponse = (status, data) => ({
+    data,
+    status,
+    headers: {},
+    statusText: '',
+    config: {},
+});
+exports.mockWorkOsResponse = mockWorkOsResponse;

package/lib/directory-sync/directory-sync.d.ts

@@ -1,19 +1,15 @@
 import { WorkOS } from '../workos';
-import { Directory } from './interfaces/directory.interface';
-import { List } from '../common/interfaces/list.interface';
-import { Group } from './interfaces/group.interface';
-import { DefaultCustomAttributes, UserWithGroups } from './interfaces/user.interface';
-import { ListDirectoriesOptions } from './interfaces/list-directories-options.interface';
-import { ListGroupsOptions } from './interfaces/list-groups-options.interface';
-import { ListUsersOptions } from './interfaces/list-users-options.interface';
+import { AutoPaginatable } from '../common/utils/pagination';
+import { DefaultCustomAttributes, Directory, DirectoryGroup, DirectoryUserWithGroups, ListDirectoriesOptions, ListDirectoryGroupsOptions, ListDirectoryUsersOptions } from './interfaces';
+import { List } from '../common/interfaces';
 export declare class DirectorySync {
     private readonly workos;
     constructor(workos: WorkOS);
-    listDirectories(options?: ListDirectoriesOptions): Promise<List<Directory>>;
+    listDirectories(options?: ListDirectoriesOptions): Promise<AutoPaginatable<Directory>>;
     getDirectory(id: string): Promise<Directory>;
     deleteDirectory(id: string): Promise<void>;
-    listGroups(options: ListGroupsOptions): Promise<List<Group>>;
-    listUsers<TCustomAttributes extends object = DefaultCustomAttributes>(options: ListUsersOptions): Promise<List<UserWithGroups<TCustomAttributes>>>;
-    getUser<TCustomAttributes extends object = DefaultCustomAttributes>(user: string): Promise<UserWithGroups<TCustomAttributes>>;
-    getGroup(group: string): Promise<Group>;
+    listGroups(options: ListDirectoryGroupsOptions): Promise<List<DirectoryGroup>>;
+    listUsers<TCustomAttributes extends object = DefaultCustomAttributes>(options: ListDirectoryUsersOptions): Promise<List<DirectoryUserWithGroups<TCustomAttributes>>>;
+    getUser<TCustomAttributes extends object = DefaultCustomAttributes>(user: string): Promise<DirectoryUserWithGroups<TCustomAttributes>>;
+    getGroup(group: string): Promise<DirectoryGroup>;
 }

package/lib/directory-sync/directory-sync.js

@@ -10,22 +10,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DirectorySync = void 0;
+const pagination_1 = require("../common/utils/pagination");
+const serializers_1 = require("./serializers");
+const fetch_and_deserialize_1 = require("../common/utils/fetch-and-deserialize");
 class DirectorySync {
     constructor(workos) {
         this.workos = workos;
     }
     listDirectories(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.workos.get('/directories', {
-                query: options,
-            });
-            return data;
+            return new pagination_1.AutoPaginatable(yield (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, '/directories', serializers_1.deserializeDirectory, options), (params) => (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, '/directories', serializers_1.deserializeDirectory, params), options);
         });
     }
     getDirectory(id) {
         return __awaiter(this, void 0, void 0, function* () {
             const { data } = yield this.workos.get(`/directories/${id}`);
-            return data;
+            return (0, serializers_1.deserializeDirectory)(data);
         });
     }
     deleteDirectory(id) {
@@ -35,30 +35,24 @@ class DirectorySync {
     }
     listGroups(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.workos.get(`/directory_groups`, {
-                query: options,
-            });
-            return data;
+            return new pagination_1.AutoPaginatable(yield (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, '/directory_groups', serializers_1.deserializeDirectoryGroup, options), (params) => (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, '/directory_groups', serializers_1.deserializeDirectoryGroup, params), options);
         });
     }
     listUsers(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.workos.get(`/directory_users`, {
-                query: options,
-            });
-            return data;
+            return new pagination_1.AutoPaginatable(yield (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, '/directory_users', serializers_1.deserializeDirectoryUserWithGroups, options), (params) => (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, '/directory_users', serializers_1.deserializeDirectoryUserWithGroups, params), options);
         });
     }
     getUser(user) {
         return __awaiter(this, void 0, void 0, function* () {
             const { data } = yield this.workos.get(`/directory_users/${user}`);
-            return data;
+            return (0, serializers_1.deserializeDirectoryUserWithGroups)(data);
         });
     }
     getGroup(group) {
         return __awaiter(this, void 0, void 0, function* () {
             const { data } = yield this.workos.get(`/directory_groups/${group}`);
-            return data;
+            return (0, serializers_1.deserializeDirectoryGroup)(data);
         });
     }
 }