@workos-inc/node 7.15.0 → 7.17.0

package/lib/fga/fga.d.ts

@@ -0,0 +1,18 @@
+import { WorkOS } from '../workos';
+import { Resource, CheckBatchOptions, CheckOptions, CheckRequestOptions, CheckResult, CreateResourceOptions, DeleteResourceOptions, ListResourcesOptions, ListWarrantsRequestOptions, ListWarrantsOptions, QueryOptions, QueryRequestOptions, QueryResult, ResourceInterface, ResourceOptions, UpdateResourceOptions, WriteWarrantOptions, Warrant, WarrantToken } from './interfaces';
+import { AutoPaginatable } from '../common/utils/pagination';
+export declare class FGA {
+    private readonly workos;
+    constructor(workos: WorkOS);
+    check(checkOptions: CheckOptions, options?: CheckRequestOptions): Promise<CheckResult>;
+    checkBatch(checkOptions: CheckBatchOptions, options?: CheckRequestOptions): Promise<CheckResult[]>;
+    createResource(resource: CreateResourceOptions): Promise<Resource>;
+    getResource(resource: ResourceInterface | ResourceOptions): Promise<Resource>;
+    listResources(options?: ListResourcesOptions): Promise<AutoPaginatable<Resource>>;
+    updateResource(options: UpdateResourceOptions): Promise<Resource>;
+    deleteResource(resource: DeleteResourceOptions): Promise<void>;
+    writeWarrant(options: WriteWarrantOptions): Promise<WarrantToken>;
+    batchWriteWarrants(options: WriteWarrantOptions[]): Promise<WarrantToken>;
+    listWarrants(options?: ListWarrantsOptions, requestOptions?: ListWarrantsRequestOptions): Promise<AutoPaginatable<Warrant>>;
+    query(options: QueryOptions, requestOptions?: QueryRequestOptions): Promise<AutoPaginatable<QueryResult>>;
+}

package/lib/fga/fga.js

@@ -0,0 +1,105 @@
+"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.FGA = void 0;
+const interfaces_1 = require("./interfaces");
+const serializers_1 = require("./serializers");
+const interface_check_1 = require("./utils/interface-check");
+const pagination_1 = require("../common/utils/pagination");
+const fetch_and_deserialize_1 = require("../common/utils/fetch-and-deserialize");
+class FGA {
+    constructor(workos) {
+        this.workos = workos;
+    }
+    check(checkOptions, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post(`/fga/v1/check`, (0, serializers_1.serializeCheckOptions)(checkOptions), options);
+            return new interfaces_1.CheckResult(data);
+        });
+    }
+    checkBatch(checkOptions, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post(`/fga/v1/check`, (0, serializers_1.serializeCheckBatchOptions)(checkOptions), options);
+            return data.map((checkResult) => new interfaces_1.CheckResult(checkResult));
+        });
+    }
+    createResource(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post('/fga/v1/resources', (0, serializers_1.serializeCreateResourceOptions)(resource));
+            return (0, serializers_1.deserializeResource)(data);
+        });
+    }
+    getResource(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resourceType = (0, interface_check_1.isResourceInterface)(resource)
+                ? resource.getResourceType()
+                : resource.resourceType;
+            const resourceId = (0, interface_check_1.isResourceInterface)(resource)
+                ? resource.getResourceId()
+                : resource.resourceId;
+            const { data } = yield this.workos.get(`/fga/v1/resources/${resourceType}/${resourceId}`);
+            return (0, serializers_1.deserializeResource)(data);
+        });
+    }
+    listResources(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new pagination_1.AutoPaginatable(yield (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, '/fga/v1/resources', serializers_1.deserializeResource, options ? (0, serializers_1.serializeListResourceOptions)(options) : undefined), (params) => (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, '/fga/v1/resources', serializers_1.deserializeResource, params), options ? (0, serializers_1.serializeListResourceOptions)(options) : undefined);
+        });
+    }
+    updateResource(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resourceType = (0, interface_check_1.isResourceInterface)(options.resource)
+                ? options.resource.getResourceType()
+                : options.resource.resourceType;
+            const resourceId = (0, interface_check_1.isResourceInterface)(options.resource)
+                ? options.resource.getResourceId()
+                : options.resource.resourceId;
+            const { data } = yield this.workos.put(`/fga/v1/resources/${resourceType}/${resourceId}`, {
+                meta: options.meta,
+            });
+            return (0, serializers_1.deserializeResource)(data);
+        });
+    }
+    deleteResource(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resourceType = (0, interface_check_1.isResourceInterface)(resource)
+                ? resource.getResourceType()
+                : resource.resourceType;
+            const resourceId = (0, interface_check_1.isResourceInterface)(resource)
+                ? resource.getResourceId()
+                : resource.resourceId;
+            yield this.workos.delete(`/fga/v1/resources/${resourceType}/${resourceId}`);
+        });
+    }
+    writeWarrant(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post('/fga/v1/warrants', (0, serializers_1.serializeWriteWarrantOptions)(options));
+            return (0, serializers_1.deserializeWarrantToken)(data);
+        });
+    }
+    batchWriteWarrants(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data: warrantToken } = yield this.workos.post('/fga/v1/warrants', options.map(serializers_1.serializeWriteWarrantOptions));
+            return (0, serializers_1.deserializeWarrantToken)(warrantToken);
+        });
+    }
+    listWarrants(options, requestOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new pagination_1.AutoPaginatable(yield (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, '/fga/v1/warrants', serializers_1.deserializeWarrant, options ? (0, serializers_1.serializeListWarrantsOptions)(options) : undefined, requestOptions), (params) => (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, '/fga/v1/warrants', serializers_1.deserializeWarrant, params, requestOptions), options ? (0, serializers_1.serializeListWarrantsOptions)(options) : undefined);
+        });
+    }
+    query(options, requestOptions = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new pagination_1.AutoPaginatable(yield (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, '/fga/v1/query', serializers_1.deserializeQueryResult, (0, serializers_1.serializeQueryOptions)(options), requestOptions), (params) => (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, '/fga/v1/query', serializers_1.deserializeQueryResult, params, requestOptions), (0, serializers_1.serializeQueryOptions)(options));
+        });
+    }
+}
+exports.FGA = FGA;

package/lib/fga/fga.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/fga/fga.spec.js

@@ -0,0 +1,518 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_fetch_mock_1 = __importDefault(require("jest-fetch-mock"));
+const test_utils_1 = require("../common/utils/test-utils");
+const workos_1 = require("../workos");
+const interfaces_1 = require("./interfaces");
+const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
+describe('FGA', () => {
+    beforeEach(() => jest_fetch_mock_1.default.resetMocks());
+    describe('check', () => {
+        it('makes check request', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                result: 'authorized',
+                is_implicit: false,
+            });
+            const checkResult = yield workos.fga.check({
+                checks: [
+                    {
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'admin',
+                        },
+                        relation: 'member',
+                        subject: {
+                            resourceType: 'user',
+                            resourceId: 'user_123',
+                        },
+                    },
+                ],
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/check');
+            expect(checkResult).toMatchObject({
+                result: 'authorized',
+                isImplicit: false,
+            });
+        }));
+    });
+    describe('createResource', () => {
+        it('creates resource', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                resource_type: 'role',
+                resource_id: 'admin',
+            });
+            const resource = yield workos.fga.createResource({
+                resource: {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                },
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources');
+            expect(resource).toMatchObject({
+                resourceType: 'role',
+                resourceId: 'admin',
+            });
+        }));
+        it('creates resource with metadata', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                resource_type: 'role',
+                resource_id: 'admin',
+                meta: {
+                    description: 'The admin role',
+                },
+            });
+            const resource = yield workos.fga.createResource({
+                resource: {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                },
+                meta: {
+                    description: 'The admin role',
+                },
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources');
+            expect(resource).toMatchObject({
+                resourceType: 'role',
+                resourceId: 'admin',
+                meta: {
+                    description: 'The admin role',
+                },
+            });
+        }));
+    });
+    describe('getResource', () => {
+        it('gets resource', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                resource_type: 'role',
+                resource_id: 'admin',
+            });
+            const resource = yield workos.fga.getResource({
+                resourceType: 'role',
+                resourceId: 'admin',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources/role/admin');
+            expect(resource).toMatchObject({
+                resourceType: 'role',
+                resourceId: 'admin',
+            });
+        }));
+    });
+    describe('listResources', () => {
+        it('lists resources', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                    },
+                    {
+                        resource_type: 'role',
+                        resource_id: 'manager',
+                    },
+                ],
+                list_metadata: {
+                    before: null,
+                    after: null,
+                },
+            });
+            const { data: resources } = yield workos.fga.listResources();
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources');
+            expect(resources).toMatchObject([
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                },
+                {
+                    resourceType: 'role',
+                    resourceId: 'manager',
+                },
+            ]);
+        }));
+        it('sends correct params when filtering', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                    },
+                    {
+                        resource_type: 'role',
+                        resource_id: 'manager',
+                    },
+                ],
+                list_metadata: {
+                    before: null,
+                    after: null,
+                },
+            });
+            yield workos.fga.listResources({
+                resourceType: 'role',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources');
+            expect((0, test_utils_1.fetchSearchParams)()).toEqual({
+                resource_type: 'role',
+                order: 'desc',
+            });
+        }));
+    });
+    describe('deleteResource', () => {
+        it('should delete resource', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)();
+            const response = yield workos.fga.deleteResource({
+                resourceType: 'role',
+                resourceId: 'admin',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources/role/admin');
+            expect(response).toBeUndefined();
+        }));
+    });
+    describe('writeWarrant', () => {
+        it('should create warrant with no op', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                warrant_token: 'some_token',
+            });
+            const warrantToken = yield workos.fga.writeWarrant({
+                resource: {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                },
+                relation: 'member',
+                subject: {
+                    resourceType: 'user',
+                    resourceId: 'user_123',
+                },
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/warrants');
+            expect((0, test_utils_1.fetchBody)()).toEqual({
+                resource_type: 'role',
+                resource_id: 'admin',
+                relation: 'member',
+                subject: {
+                    resource_type: 'user',
+                    resource_id: 'user_123',
+                },
+            });
+            expect(warrantToken).toMatchObject({
+                warrantToken: 'some_token',
+            });
+        }));
+        it('should create warrant with create op', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                warrant_token: 'some_token',
+            });
+            const warrantToken = yield workos.fga.writeWarrant({
+                op: interfaces_1.WarrantOp.Create,
+                resource: {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                },
+                relation: 'member',
+                subject: {
+                    resourceType: 'user',
+                    resourceId: 'user_123',
+                },
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/warrants');
+            expect((0, test_utils_1.fetchBody)()).toEqual({
+                op: 'create',
+                resource_type: 'role',
+                resource_id: 'admin',
+                relation: 'member',
+                subject: {
+                    resource_type: 'user',
+                    resource_id: 'user_123',
+                },
+            });
+            expect(warrantToken).toMatchObject({
+                warrantToken: 'some_token',
+            });
+        }));
+        it('should delete warrant with delete op', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                warrant_token: 'some_token',
+            });
+            const warrantToken = yield workos.fga.writeWarrant({
+                op: interfaces_1.WarrantOp.Delete,
+                resource: {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                },
+                relation: 'member',
+                subject: {
+                    resourceType: 'user',
+                    resourceId: 'user_123',
+                },
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/warrants');
+            expect((0, test_utils_1.fetchBody)()).toEqual({
+                op: 'delete',
+                resource_type: 'role',
+                resource_id: 'admin',
+                relation: 'member',
+                subject: {
+                    resource_type: 'user',
+                    resource_id: 'user_123',
+                },
+            });
+            expect(warrantToken).toMatchObject({
+                warrantToken: 'some_token',
+            });
+        }));
+    });
+    describe('batchWriteWarrants', () => {
+        it('should create warrants with no op or create op and delete warrants with delete op', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                warrant_token: 'some_token',
+            });
+            const warrantToken = yield workos.fga.batchWriteWarrants([
+                {
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_123',
+                    },
+                },
+                {
+                    op: interfaces_1.WarrantOp.Create,
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_124',
+                    },
+                },
+                {
+                    op: interfaces_1.WarrantOp.Delete,
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_125',
+                    },
+                },
+            ]);
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/warrants');
+            expect((0, test_utils_1.fetchBody)()).toEqual([
+                {
+                    resource_type: 'role',
+                    resource_id: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resource_type: 'user',
+                        resource_id: 'user_123',
+                    },
+                },
+                {
+                    op: 'create',
+                    resource_type: 'role',
+                    resource_id: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resource_type: 'user',
+                        resource_id: 'user_124',
+                    },
+                },
+                {
+                    op: 'delete',
+                    resource_type: 'role',
+                    resource_id: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resource_type: 'user',
+                        resource_id: 'user_125',
+                    },
+                },
+            ]);
+            expect(warrantToken).toMatchObject({
+                warrantToken: 'some_token',
+            });
+        }));
+    });
+    describe('listWarrants', () => {
+        it('should list warrants', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                        relation: 'member',
+                        subject: {
+                            resource_type: 'user',
+                            resource_id: 'user_123',
+                        },
+                    },
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                        relation: 'member',
+                        subject: {
+                            resource_type: 'user',
+                            resource_id: 'user_124',
+                        },
+                    },
+                ],
+                list_metadata: {
+                    before: null,
+                    after: null,
+                },
+            });
+            const { data: warrants } = yield workos.fga.listWarrants();
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/warrants');
+            expect(warrants).toMatchObject([
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_123',
+                    },
+                },
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_124',
+                    },
+                },
+            ]);
+        }));
+        it('sends correct params when filtering', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                        relation: 'member',
+                        subject: {
+                            resource_type: 'user',
+                            resource_id: 'user_123',
+                        },
+                    },
+                ],
+                list_metadata: {
+                    before: null,
+                    after: null,
+                },
+            });
+            yield workos.fga.listWarrants({
+                subjectType: 'user',
+                subjectId: 'user_123',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/warrants');
+            expect((0, test_utils_1.fetchSearchParams)()).toEqual({
+                subject_type: 'user',
+                subject_id: 'user_123',
+                order: 'desc',
+            });
+        }));
+    });
+    describe('query', () => {
+        it('makes query request', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                        warrant: {
+                            resource_type: 'role',
+                            resource_id: 'admin',
+                            relation: 'member',
+                            subject: {
+                                resource_type: 'user',
+                                resource_id: 'user_123',
+                            },
+                        },
+                        is_implicit: false,
+                    },
+                ],
+                list_metadata: {
+                    before: null,
+                    after: null,
+                },
+            });
+            const { data: queryResults } = yield workos.fga.query({
+                q: 'select role where user:user_123 is member',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/query');
+            expect(queryResults).toMatchObject([
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                    warrant: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                        relation: 'member',
+                        subject: {
+                            resourceType: 'user',
+                            resourceId: 'user_123',
+                        },
+                    },
+                    isImplicit: false,
+                },
+            ]);
+        }));
+        it('sends correct params and options', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                        warrant: {
+                            resourceType: 'role',
+                            resourceId: 'admin',
+                            relation: 'member',
+                            subject: {
+                                resourceType: 'user',
+                                resourceId: 'user_123',
+                            },
+                        },
+                        isImplicit: false,
+                    },
+                ],
+                list_metadata: {
+                    before: null,
+                    after: null,
+                },
+            });
+            yield workos.fga.query({
+                q: 'select role where user:user_123 is member',
+                order: 'asc',
+            }, {
+                warrantToken: 'some_token',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/query');
+            expect((0, test_utils_1.fetchSearchParams)()).toEqual({
+                q: 'select role where user:user_123 is member',
+                order: 'asc',
+            });
+            expect((0, test_utils_1.fetchHeaders)()).toMatchObject({
+                'Warrant-Token': 'some_token',
+            });
+        }));
+    });
+});

package/lib/fga/interfaces/check-op.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum CheckOp {
+    AllOf = "all_of",
+    AnyOf = "any_of",
+    Batch = "batch"
+}

package/lib/fga/interfaces/check-op.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckOp = void 0;
+var CheckOp;
+(function (CheckOp) {
+    CheckOp["AllOf"] = "all_of";
+    CheckOp["AnyOf"] = "any_of";
+    CheckOp["Batch"] = "batch";
+})(CheckOp || (exports.CheckOp = CheckOp = {}));