@workos-inc/node 7.16.0 → 7.17.1

package/lib/fga/interfaces/check.interface.d.ts

@@ -0,0 +1,71 @@
+import { ResourceInterface, ResourceOptions } from './resource.interface';
+import { PolicyContext, SerializedSubject, Subject } from './warrant.interface';
+import { CheckOp } from './check-op.enum';
+import { PostOptions } from '../../common/interfaces';
+export interface CheckWarrantOptions {
+    resource: ResourceInterface | ResourceOptions;
+    relation: string;
+    subject: ResourceInterface | Subject;
+    context?: PolicyContext;
+}
+export interface SerializedCheckWarrantOptions {
+    resource_type: string;
+    resource_id: string;
+    relation: string;
+    subject: SerializedSubject;
+    context: PolicyContext;
+}
+export interface CheckOptions {
+    op?: CheckOp;
+    checks: CheckWarrantOptions[];
+    debug?: boolean;
+}
+export interface CheckBatchOptions {
+    checks: CheckWarrantOptions[];
+    debug?: boolean;
+}
+export interface SerializedCheckOptions {
+    op?: CheckOp;
+    checks: SerializedCheckWarrantOptions[];
+    debug?: boolean;
+}
+export interface CheckResultResponse {
+    result: string;
+    is_implicit: boolean;
+    debug_info?: DebugInfoResponse;
+}
+export interface DebugInfo {
+    processingTime: number;
+    decisionTree: DecisionTreeNode;
+}
+export interface DecisionTreeNode {
+    check: CheckWarrantOptions;
+    policy?: string;
+    decision: string;
+    processingTime: number;
+    children: DecisionTreeNode[];
+}
+export interface DebugInfoResponse {
+    processing_time: number;
+    decision_tree: DecisionTreeNodeResponse;
+}
+export interface DecisionTreeNodeResponse {
+    check: SerializedCheckWarrantOptions;
+    policy?: string;
+    decision: string;
+    processing_time: number;
+    children: DecisionTreeNodeResponse[];
+}
+export interface CheckResultInterface {
+    result: string;
+    isImplicit: boolean;
+    debugInfo?: DebugInfo;
+}
+export declare class CheckResult implements CheckResultInterface {
+    result: string;
+    isImplicit: boolean;
+    debugInfo?: DebugInfo;
+    constructor(json: CheckResultResponse);
+    isAuthorized(): boolean;
+}
+export type CheckRequestOptions = Pick<PostOptions, 'warrantToken'>;

package/lib/fga/interfaces/check.interface.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckResult = void 0;
+const check_options_serializer_1 = require("../serializers/check-options.serializer");
+const CHECK_RESULT_AUTHORIZED = 'authorized';
+class CheckResult {
+    constructor(json) {
+        this.result = json.result;
+        this.isImplicit = json.is_implicit;
+        this.debugInfo = json.debug_info
+            ? {
+                processingTime: json.debug_info.processing_time,
+                decisionTree: (0, check_options_serializer_1.deserializeDecisionTreeNode)(json.debug_info.decision_tree),
+            }
+            : undefined;
+    }
+    isAuthorized() {
+        return this.result === CHECK_RESULT_AUTHORIZED;
+    }
+}
+exports.CheckResult = CheckResult;

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

@@ -0,0 +1,7 @@
+export * from './check-op.enum';
+export * from './check.interface';
+export * from './query.interface';
+export * from './resource.interface';
+export * from './warrant-op.enum';
+export * from './warrant-token.interface';
+export * from './warrant.interface';

package/lib/fga/interfaces/index.js

@@ -0,0 +1,23 @@
+"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("./check-op.enum"), exports);
+__exportStar(require("./check.interface"), exports);
+__exportStar(require("./query.interface"), exports);
+__exportStar(require("./resource.interface"), exports);
+__exportStar(require("./warrant-op.enum"), exports);
+__exportStar(require("./warrant-token.interface"), exports);
+__exportStar(require("./warrant.interface"), exports);

package/lib/fga/interfaces/query.interface.d.ts

@@ -0,0 +1,30 @@
+import { Warrant, PolicyContext, WarrantResponse } from './warrant.interface';
+import { PaginationOptions } from '../../common/interfaces/pagination-options.interface';
+import { GetOptions } from '../../common/interfaces';
+export interface QueryOptions extends PaginationOptions {
+    q: string;
+    context?: PolicyContext;
+}
+export interface SerializedQueryOptions extends PaginationOptions {
+    q: string;
+    context?: string;
+}
+export interface QueryResult {
+    resourceType: string;
+    resourceId: string;
+    relation: string;
+    warrant: Warrant;
+    isImplicit: boolean;
+    meta?: {
+        [key: string]: any;
+    };
+}
+export interface QueryResultResponse {
+    resource_type: string;
+    resource_id: string;
+    relation: string;
+    warrant: WarrantResponse;
+    is_implicit: boolean;
+    meta?: Record<string, any>;
+}
+export type QueryRequestOptions = Pick<GetOptions, 'warrantToken'>;

package/lib/fga/interfaces/query.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/fga/interfaces/resource.interface.d.ts

@@ -0,0 +1,60 @@
+import { PaginationOptions } from '../../common/interfaces/pagination-options.interface';
+export interface ResourceInterface {
+    getResourceType(): string;
+    getResourceId(): string;
+}
+export interface ResourceOptions {
+    resourceType: string;
+    resourceId?: string;
+}
+export interface SerializedResourceOptions {
+    resource_type: string;
+    resource_id?: string;
+}
+export interface CreateResourceOptions {
+    resource: ResourceInterface | ResourceOptions;
+    meta?: {
+        [key: string]: any;
+    };
+}
+export interface SerializedCreateResourceOptions {
+    resource_type: string;
+    resource_id?: string;
+    meta?: {
+        [key: string]: any;
+    };
+}
+export type GetResourceOptions = ResourceInterface | ResourceOptions;
+export interface ListResourcesOptions extends PaginationOptions {
+    resourceType?: string;
+    search?: string;
+}
+export interface SerializedListResourcesOptions extends PaginationOptions {
+    resource_type?: string;
+    search?: string;
+}
+export interface UpdateResourceOptions {
+    resource: ResourceInterface | ResourceOptions;
+    meta: {
+        [key: string]: any;
+    };
+}
+export type DeleteResourceOptions = ResourceInterface | ResourceOptions;
+export interface SerializedDeleteResourceOptions {
+    resource_type: string;
+    resource_id: string;
+}
+export interface Resource {
+    resourceType: string;
+    resourceId: string;
+    meta?: {
+        [key: string]: any;
+    };
+}
+export interface ResourceResponse {
+    resource_type: string;
+    resource_id: string;
+    meta?: {
+        [key: string]: any;
+    };
+}

package/lib/fga/interfaces/resource.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+export declare enum WarrantOp {
+    Create = "create",
+    Delete = "delete"
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WarrantOp = void 0;
+var WarrantOp;
+(function (WarrantOp) {
+    WarrantOp["Create"] = "create";
+    WarrantOp["Delete"] = "delete";
+})(WarrantOp || (exports.WarrantOp = WarrantOp = {}));

package/lib/fga/interfaces/warrant-token.interface.d.ts

@@ -0,0 +1,6 @@
+export interface WarrantToken {
+    warrantToken: string;
+}
+export interface WarrantTokenResponse {
+    warrant_token: string;
+}

package/lib/fga/interfaces/warrant-token.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/fga/interfaces/warrant.interface.d.ts

@@ -0,0 +1,65 @@
+import { GetOptions } from '../../common/interfaces';
+import { ResourceInterface, ResourceOptions } from './resource.interface';
+import { WarrantOp } from './warrant-op.enum';
+export interface ListWarrantsOptions {
+    resourceType?: string;
+    resourceId?: string;
+    relation?: string;
+    subjectType?: string;
+    subjectId?: string;
+    subjectRelation?: string;
+    limit?: number;
+    after?: string;
+}
+export interface SerializedListWarrantsOptions {
+    resource_type?: string;
+    resource_id?: string;
+    relation?: string;
+    subject_type?: string;
+    subject_id?: string;
+    subject_relation?: string;
+    limit?: number;
+    after?: string;
+}
+export interface PolicyContext {
+    [key: string]: any;
+}
+export interface Subject {
+    resourceType: string;
+    resourceId: string;
+    relation?: string;
+}
+export interface SerializedSubject {
+    resource_type: string;
+    resource_id: string;
+    relation?: string;
+}
+export interface Warrant {
+    resourceType: string;
+    resourceId: string;
+    relation: string;
+    subject: Subject;
+    policy?: string;
+}
+export interface WriteWarrantOptions {
+    op?: WarrantOp;
+    resource: ResourceInterface | ResourceOptions;
+    relation: string;
+    subject: ResourceInterface | Subject;
+    policy?: string;
+}
+export interface SerializedWriteWarrantOptions {
+    op?: WarrantOp;
+    resource_type: string;
+    resource_id: string;
+    relation: string;
+    subject: SerializedSubject;
+    policy?: string;
+}
+export type ListWarrantsRequestOptions = Pick<GetOptions, 'warrantToken'>;
+export interface WarrantResponse {
+    resource_type: string;
+    resource_id: string;
+    relation: string;
+    subject: SerializedSubject;
+}

package/lib/fga/interfaces/warrant.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/fga/serializers/check-options.serializer.d.ts

@@ -0,0 +1,4 @@
+import { CheckBatchOptions, CheckOptions, DecisionTreeNode, DecisionTreeNodeResponse, SerializedCheckOptions } from '../interfaces';
+export declare const serializeCheckOptions: (options: CheckOptions) => SerializedCheckOptions;
+export declare const serializeCheckBatchOptions: (options: CheckBatchOptions) => SerializedCheckOptions;
+export declare const deserializeDecisionTreeNode: (response: DecisionTreeNodeResponse) => DecisionTreeNode;

package/lib/fga/serializers/check-options.serializer.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeDecisionTreeNode = exports.serializeCheckBatchOptions = exports.serializeCheckOptions = void 0;
+const interfaces_1 = require("../interfaces");
+const interface_check_1 = require("../utils/interface-check");
+const serializeCheckOptions = (options) => ({
+    op: options.op,
+    checks: options.checks.map(serializeCheckWarrantOptions),
+    debug: options.debug,
+});
+exports.serializeCheckOptions = serializeCheckOptions;
+const serializeCheckBatchOptions = (options) => ({
+    op: interfaces_1.CheckOp.Batch,
+    checks: options.checks.map(serializeCheckWarrantOptions),
+    debug: options.debug,
+});
+exports.serializeCheckBatchOptions = serializeCheckBatchOptions;
+const serializeCheckWarrantOptions = (warrant) => {
+    var _a;
+    return {
+        resource_type: (0, interface_check_1.isResourceInterface)(warrant.resource)
+            ? warrant.resource.getResourceType()
+            : warrant.resource.resourceType,
+        resource_id: (0, interface_check_1.isResourceInterface)(warrant.resource)
+            ? warrant.resource.getResourceId()
+            : warrant.resource.resourceId
+                ? warrant.resource.resourceId
+                : '',
+        relation: warrant.relation,
+        subject: (0, interface_check_1.isSubject)(warrant.subject)
+            ? {
+                resource_type: warrant.subject.resourceType,
+                resource_id: warrant.subject.resourceId,
+            }
+            : {
+                resource_type: warrant.subject.getResourceType(),
+                resource_id: warrant.subject.getResourceId(),
+            },
+        context: (_a = warrant.context) !== null && _a !== void 0 ? _a : {},
+    };
+};
+const deserializeDecisionTreeNode = (response) => {
+    return {
+        check: {
+            resource: {
+                resourceType: response.check.resource_type,
+                resourceId: response.check.resource_id,
+            },
+            relation: response.check.relation,
+            subject: {
+                resourceType: response.check.subject.resource_type,
+                resourceId: response.check.subject.resource_id,
+            },
+            context: response.check.context,
+        },
+        policy: response.policy,
+        decision: response.decision,
+        processingTime: response.processing_time,
+        children: response.children.map(exports.deserializeDecisionTreeNode),
+    };
+};
+exports.deserializeDecisionTreeNode = deserializeDecisionTreeNode;

package/lib/fga/serializers/create-resource-options.serializer.d.ts

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

package/lib/fga/serializers/create-resource-options.serializer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeCreateResourceOptions = void 0;
+const interface_check_1 = require("../utils/interface-check");
+const serializeCreateResourceOptions = (options) => ({
+    resource_type: (0, interface_check_1.isResourceInterface)(options.resource)
+        ? options.resource.getResourceType()
+        : options.resource.resourceType,
+    resource_id: (0, interface_check_1.isResourceInterface)(options.resource)
+        ? options.resource.getResourceId()
+        : options.resource.resourceId
+            ? options.resource.resourceId
+            : '',
+    meta: options.meta,
+});
+exports.serializeCreateResourceOptions = serializeCreateResourceOptions;

package/lib/fga/serializers/delete-resource-options.serializer.d.ts

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

package/lib/fga/serializers/delete-resource-options.serializer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeDeleteResourceOptions = void 0;
+const interface_check_1 = require("../utils/interface-check");
+const serializeDeleteResourceOptions = (options) => ({
+    resource_type: (0, interface_check_1.isResourceInterface)(options)
+        ? options.getResourceType()
+        : options.resourceType,
+    resource_id: (0, interface_check_1.isResourceInterface)(options)
+        ? options.getResourceId()
+        : options.resourceId
+            ? options.resourceId
+            : '',
+});
+exports.serializeDeleteResourceOptions = serializeDeleteResourceOptions;

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

@@ -0,0 +1,11 @@
+export * from './check-options.serializer';
+export * from './create-resource-options.serializer';
+export * from './delete-resource-options.serializer';
+export * from './list-resources-options.serializer';
+export * from './list-warrants-options.serializer';
+export * from './query-options.serializer';
+export * from './query-result.serializer';
+export * from './resource.serializer';
+export * from './warrant-token.serializer';
+export * from './warrant.serializer';
+export * from './write-warrant-options.serializer';

package/lib/fga/serializers/index.js

@@ -0,0 +1,27 @@
+"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("./check-options.serializer"), exports);
+__exportStar(require("./create-resource-options.serializer"), exports);
+__exportStar(require("./delete-resource-options.serializer"), exports);
+__exportStar(require("./list-resources-options.serializer"), exports);
+__exportStar(require("./list-warrants-options.serializer"), exports);
+__exportStar(require("./query-options.serializer"), exports);
+__exportStar(require("./query-result.serializer"), exports);
+__exportStar(require("./resource.serializer"), exports);
+__exportStar(require("./warrant-token.serializer"), exports);
+__exportStar(require("./warrant.serializer"), exports);
+__exportStar(require("./write-warrant-options.serializer"), exports);

package/lib/fga/serializers/list-resources-options.serializer.d.ts

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

package/lib/fga/serializers/list-resources-options.serializer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeListResourceOptions = void 0;
+const serializeListResourceOptions = (options) => ({
+    resource_type: options.resourceType,
+    search: options.search,
+    limit: options.limit,
+    before: options.before,
+    after: options.after,
+    order: options.order,
+});
+exports.serializeListResourceOptions = serializeListResourceOptions;

package/lib/fga/serializers/list-warrants-options.serializer.d.ts

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

package/lib/fga/serializers/list-warrants-options.serializer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeListWarrantsOptions = void 0;
+const serializeListWarrantsOptions = (options) => ({
+    resource_type: options.resourceType,
+    resource_id: options.resourceId,
+    relation: options.relation,
+    subject_type: options.subjectType,
+    subject_id: options.subjectId,
+    subject_relation: options.subjectRelation,
+    limit: options.limit,
+    after: options.after,
+});
+exports.serializeListWarrantsOptions = serializeListWarrantsOptions;

package/lib/fga/serializers/query-options.serializer.d.ts

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

package/lib/fga/serializers/query-options.serializer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeQueryOptions = void 0;
+const serializeQueryOptions = (options) => ({
+    q: options.q,
+    context: JSON.stringify(options.context),
+    limit: options.limit,
+    before: options.before,
+    after: options.after,
+    order: options.order,
+});
+exports.serializeQueryOptions = serializeQueryOptions;

package/lib/fga/serializers/query-result.serializer.d.ts

@@ -0,0 +1,2 @@
+import { QueryResult, QueryResultResponse } from '../interfaces';
+export declare const deserializeQueryResult: (queryResult: QueryResultResponse) => QueryResult;

package/lib/fga/serializers/query-result.serializer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeQueryResult = void 0;
+const deserializeQueryResult = (queryResult) => ({
+    resourceType: queryResult.resource_type,
+    resourceId: queryResult.resource_id,
+    relation: queryResult.relation,
+    warrant: {
+        resourceType: queryResult.warrant.resource_type,
+        resourceId: queryResult.warrant.resource_id,
+        relation: queryResult.warrant.relation,
+        subject: {
+            resourceType: queryResult.warrant.subject.resource_type,
+            resourceId: queryResult.warrant.subject.resource_id,
+            relation: queryResult.warrant.subject.relation,
+        },
+    },
+    isImplicit: queryResult.is_implicit,
+    meta: queryResult.meta,
+});
+exports.deserializeQueryResult = deserializeQueryResult;

package/lib/fga/serializers/resource.serializer.d.ts

@@ -0,0 +1,2 @@
+import { Resource, ResourceResponse } from '../interfaces';
+export declare const deserializeResource: (response: ResourceResponse) => Resource;

package/lib/fga/serializers/resource.serializer.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeResource = void 0;
+const deserializeResource = (response) => ({
+    resourceType: response.resource_type,
+    resourceId: response.resource_id,
+    meta: response.meta,
+});
+exports.deserializeResource = deserializeResource;

package/lib/fga/serializers/warrant-token.serializer.d.ts

@@ -0,0 +1,2 @@
+import { WarrantToken, WarrantTokenResponse } from '../interfaces/warrant-token.interface';
+export declare const deserializeWarrantToken: (warrantToken: WarrantTokenResponse) => WarrantToken;

package/lib/fga/serializers/warrant-token.serializer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeWarrantToken = void 0;
+const deserializeWarrantToken = (warrantToken) => ({
+    warrantToken: warrantToken.warrant_token,
+});
+exports.deserializeWarrantToken = deserializeWarrantToken;

package/lib/fga/serializers/warrant.serializer.d.ts

@@ -0,0 +1,2 @@
+import { Warrant, WarrantResponse } from '../interfaces';
+export declare const deserializeWarrant: (warrant: WarrantResponse) => Warrant;

package/lib/fga/serializers/warrant.serializer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeWarrant = void 0;
+const deserializeWarrant = (warrant) => ({
+    resourceType: warrant.resource_type,
+    resourceId: warrant.resource_id,
+    relation: warrant.relation,
+    subject: {
+        resourceType: warrant.subject.resource_type,
+        resourceId: warrant.subject.resource_id,
+        relation: warrant.subject.relation,
+    },
+});
+exports.deserializeWarrant = deserializeWarrant;

package/lib/fga/serializers/write-warrant-options.serializer.d.ts

@@ -0,0 +1,2 @@
+import { SerializedWriteWarrantOptions, WriteWarrantOptions } from '../interfaces';
+export declare const serializeWriteWarrantOptions: (warrant: WriteWarrantOptions) => SerializedWriteWarrantOptions;

package/lib/fga/serializers/write-warrant-options.serializer.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeWriteWarrantOptions = void 0;
+const interface_check_1 = require("../utils/interface-check");
+const serializeWriteWarrantOptions = (warrant) => ({
+    op: warrant.op,
+    resource_type: (0, interface_check_1.isResourceInterface)(warrant.resource)
+        ? warrant.resource.getResourceType()
+        : warrant.resource.resourceType,
+    resource_id: (0, interface_check_1.isResourceInterface)(warrant.resource)
+        ? warrant.resource.getResourceId()
+        : warrant.resource.resourceId
+            ? warrant.resource.resourceId
+            : '',
+    relation: warrant.relation,
+    subject: (0, interface_check_1.isSubject)(warrant.subject)
+        ? {
+            resource_type: warrant.subject.resourceType,
+            resource_id: warrant.subject.resourceId,
+        }
+        : {
+            resource_type: warrant.subject.getResourceType(),
+            resource_id: warrant.subject.getResourceId(),
+        },
+    policy: warrant.policy,
+});
+exports.serializeWriteWarrantOptions = serializeWriteWarrantOptions;

package/lib/fga/utils/interface-check.d.ts

@@ -0,0 +1,3 @@
+import { Subject, ResourceInterface } from '../interfaces';
+export declare function isSubject(resource: any): resource is Subject;
+export declare function isResourceInterface(resource: unknown): resource is ResourceInterface;