@schematichq/schematic-typescript-node 1.0.22 → 1.1.0

package/dist/core/schemas/utils/createIdentitySchemaCreator.d.ts

@@ -0,0 +1,2 @@
+import { MaybeValid, Schema, SchemaOptions, SchemaType } from "../Schema";
+export declare function createIdentitySchemaCreator<T>(schemaType: SchemaType, validate: (value: unknown, opts?: SchemaOptions) => MaybeValid<T>): () => Schema<T, T>;

package/dist/core/schemas/utils/createIdentitySchemaCreator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIdentitySchemaCreator = void 0;
+const schema_utils_1 = require("../builders/schema-utils");
+const maybeSkipValidation_1 = require("./maybeSkipValidation");
+function createIdentitySchemaCreator(schemaType, validate) {
+    return () => {
+        const baseSchema = {
+            parse: validate,
+            json: validate,
+            getType: () => schemaType,
+        };
+        return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+    };
+}
+exports.createIdentitySchemaCreator = createIdentitySchemaCreator;

package/dist/core/schemas/utils/entries.d.ts

@@ -0,0 +1 @@
+export declare function entries<T>(object: T): [keyof T, T[keyof T]][];

package/dist/core/schemas/utils/entries.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entries = void 0;
+function entries(object) {
+    return Object.entries(object);
+}
+exports.entries = entries;

package/dist/core/schemas/utils/filterObject.d.ts

@@ -0,0 +1 @@
+export declare function filterObject<T, K extends keyof T>(obj: T, keysToInclude: K[]): Pick<T, K>;

package/dist/core/schemas/utils/filterObject.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterObject = void 0;
+function filterObject(obj, keysToInclude) {
+    const keysToIncludeSet = new Set(keysToInclude);
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        if (keysToIncludeSet.has(key)) {
+            acc[key] = value;
+        }
+        return acc;
+        // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter
+    }, {});
+}
+exports.filterObject = filterObject;

package/dist/core/schemas/utils/getErrorMessageForIncorrectType.d.ts

@@ -0,0 +1 @@
+export declare function getErrorMessageForIncorrectType(value: unknown, expectedType: string): string;

package/dist/core/schemas/utils/getErrorMessageForIncorrectType.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorMessageForIncorrectType = void 0;
+function getErrorMessageForIncorrectType(value, expectedType) {
+    return `Expected ${expectedType}. Received ${getTypeAsString(value)}.`;
+}
+exports.getErrorMessageForIncorrectType = getErrorMessageForIncorrectType;
+function getTypeAsString(value) {
+    if (Array.isArray(value)) {
+        return "list";
+    }
+    if (value === null) {
+        return "null";
+    }
+    switch (typeof value) {
+        case "string":
+            return `"${value}"`;
+        case "number":
+        case "boolean":
+        case "undefined":
+            return `${value}`;
+    }
+    return typeof value;
+}

package/dist/core/schemas/utils/isPlainObject.d.ts

@@ -0,0 +1 @@
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;

package/dist/core/schemas/utils/isPlainObject.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = void 0;
+// borrowed from https://github.com/lodash/lodash/blob/master/isPlainObject.js
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    if (Object.getPrototypeOf(value) === null) {
+        return true;
+    }
+    let proto = value;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(value) === proto;
+}
+exports.isPlainObject = isPlainObject;

package/dist/core/schemas/utils/keys.d.ts

@@ -0,0 +1 @@
+export declare function keys<T>(object: T): (keyof T)[];

package/dist/core/schemas/utils/keys.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keys = void 0;
+function keys(object) {
+    return Object.keys(object);
+}
+exports.keys = keys;

package/dist/core/schemas/utils/maybeSkipValidation.d.ts

@@ -0,0 +1,2 @@
+import { BaseSchema } from "../Schema";
+export declare function maybeSkipValidation<S extends BaseSchema<Raw, Parsed>, Raw, Parsed>(schema: S): S;

package/dist/core/schemas/utils/maybeSkipValidation.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeSkipValidation = void 0;
+function maybeSkipValidation(schema) {
+    return Object.assign(Object.assign({}, schema), { json: transformAndMaybeSkipValidation(schema.json), parse: transformAndMaybeSkipValidation(schema.parse) });
+}
+exports.maybeSkipValidation = maybeSkipValidation;
+function transformAndMaybeSkipValidation(transform) {
+    return (value, opts) => {
+        const transformed = transform(value, opts);
+        const { skipValidation = false } = opts !== null && opts !== void 0 ? opts : {};
+        if (!transformed.ok && skipValidation) {
+            // eslint-disable-next-line no-console
+            console.warn([
+                "Failed to validate.",
+                ...transformed.errors.map((error) => "  - " +
+                    (error.path.length > 0 ? `${error.path.join(".")}: ${error.message}` : error.message)),
+            ].join("\n"));
+            return {
+                ok: true,
+                value: value,
+            };
+        }
+        else {
+            return transformed;
+        }
+    };
+}

package/dist/core/schemas/utils/partition.d.ts

@@ -0,0 +1 @@
+export declare function partition<T>(items: readonly T[], predicate: (item: T) => boolean): [T[], T[]];

package/dist/core/schemas/utils/partition.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partition = void 0;
+function partition(items, predicate) {
+    const trueItems = [], falseItems = [];
+    for (const item of items) {
+        if (predicate(item)) {
+            trueItems.push(item);
+        }
+        else {
+            falseItems.push(item);
+        }
+    }
+    return [trueItems, falseItems];
+}
+exports.partition = partition;

package/dist/environments.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare const SchematicEnvironment: {
+    readonly Default: "https://api.schematichq.com";
+};
+export declare type SchematicEnvironment = typeof SchematicEnvironment.Default;

package/dist/environments.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchematicEnvironment = void 0;
+exports.SchematicEnvironment = {
+    Default: "https://api.schematichq.com",
+};

package/dist/errors/SchematicError.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare class SchematicError extends Error {
+    readonly statusCode?: number;
+    readonly body?: unknown;
+    constructor({ message, statusCode, body }: {
+        message?: string;
+        statusCode?: number;
+        body?: unknown;
+    });
+}

package/dist/errors/SchematicError.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchematicError = void 0;
+class SchematicError extends Error {
+    constructor({ message, statusCode, body }) {
+        super(buildMessage({ message, statusCode, body }));
+        Object.setPrototypeOf(this, SchematicError.prototype);
+        if (statusCode != null) {
+            this.statusCode = statusCode;
+        }
+        if (body !== undefined) {
+            this.body = body;
+        }
+    }
+}
+exports.SchematicError = SchematicError;
+function buildMessage({ message, statusCode, body, }) {
+    let lines = [];
+    if (message != null) {
+        lines.push(message);
+    }
+    if (statusCode != null) {
+        lines.push(`Status code: ${statusCode.toString()}`);
+    }
+    if (body != null) {
+        lines.push(`Body: ${JSON.stringify(body, undefined, 2)}`);
+    }
+    return lines.join("\n");
+}

package/dist/errors/SchematicTimeoutError.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare class SchematicTimeoutError extends Error {
+    constructor();
+}

package/dist/errors/SchematicTimeoutError.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchematicTimeoutError = void 0;
+class SchematicTimeoutError extends Error {
+    constructor() {
+        super("Timeout");
+        Object.setPrototypeOf(this, SchematicTimeoutError.prototype);
+    }
+}
+exports.SchematicTimeoutError = SchematicTimeoutError;

package/dist/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { SchematicError } from "./SchematicError";
+export { SchematicTimeoutError } from "./SchematicTimeoutError";

package/dist/errors/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchematicTimeoutError = exports.SchematicError = void 0;
+var SchematicError_1 = require("./SchematicError");
+Object.defineProperty(exports, "SchematicError", { enumerable: true, get: function () { return SchematicError_1.SchematicError; } });
+var SchematicTimeoutError_1 = require("./SchematicTimeoutError");
+Object.defineProperty(exports, "SchematicTimeoutError", { enumerable: true, get: function () { return SchematicTimeoutError_1.SchematicTimeoutError; } });

package/dist/events.d.ts

@@ -0,0 +1,23 @@
+import { CreateEventRequestBody } from "./api";
+import { Events } from "./api/resources/events/client/Client";
+import { Logger } from "./logger";
+interface EventBufferOptions {
+    interval?: number;
+    logger?: Logger;
+    maxSize?: number;
+}
+declare class EventBuffer {
+    private events;
+    private eventsApi;
+    private interval;
+    private logger;
+    private maxSize;
+    private shutdown;
+    private stopped;
+    constructor(eventsApi: Events, opts?: EventBufferOptions);
+    flush(): Promise<void>;
+    push(event: CreateEventRequestBody): Promise<void>;
+    stop(): Promise<void>;
+    private startPeriodicFlush;
+}
+export { EventBuffer };

package/dist/events.js

@@ -0,0 +1,70 @@
+"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.EventBuffer = void 0;
+const logger_1 = require("./logger");
+const DEFAULT_FLUSH_INTERVAL = 1000; // 1 second
+const DEFAULT_MAX_SIZE = 1000; // 1000 items
+class EventBuffer {
+    constructor(eventsApi, opts) {
+        this.events = [];
+        this.shutdown = false;
+        this.stopped = false;
+        const { logger, maxSize, interval } = opts || {};
+        this.eventsApi = eventsApi;
+        this.interval = interval || DEFAULT_FLUSH_INTERVAL;
+        this.logger = logger || new logger_1.ConsoleLogger();
+        this.maxSize = maxSize || DEFAULT_MAX_SIZE;
+        this.startPeriodicFlush();
+    }
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.events.length === 0) {
+                return;
+            }
+            const events = [...this.events];
+            this.events = [];
+            try {
+                yield this.eventsApi.createEventBatch({ events });
+            }
+            catch (err) {
+                this.logger.error("Failed to flush events", err);
+            }
+        });
+    }
+    push(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.stopped) {
+                this.logger.error("Event buffer is stopped, not accepting new events");
+                return;
+            }
+            if (this.events.length >= this.maxSize) {
+                yield this.flush();
+            }
+            this.events.push(event);
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.shutdown = true;
+            this.stopped = true;
+            yield this.flush();
+        });
+    }
+    startPeriodicFlush() {
+        setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            if (this.shutdown)
+                return;
+            yield this.flush();
+        }), this.interval);
+    }
+}
+exports.EventBuffer = EventBuffer;

package/dist/events.test.d.ts

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

package/dist/events.test.js

@@ -0,0 +1,148 @@
+"use strict";
+/* eslint @typescript-eslint/no-explicit-any: 0 */
+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 });
+const events_1 = require("./events");
+jest.useFakeTimers();
+describe("EventBuffer", () => {
+    let mockEventsApi;
+    let mockLogger;
+    beforeEach(() => {
+        mockEventsApi = {
+            createEventBatch: jest.fn().mockResolvedValue(undefined),
+        };
+        mockLogger = {
+            error: jest.fn(),
+            log: jest.fn(),
+        };
+    });
+    it("should push and flush events correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+        const event1 = {
+            body: {
+                company: { id: "test-company" },
+                event: "test-event",
+                user: { id: "test-user" },
+            },
+            eventType: "track",
+            sentAt: new Date(),
+        };
+        const event2 = {
+            body: {
+                company: { id: "test-company" },
+                event: "test-event-2",
+                user: { id: "test-user" },
+            },
+            eventType: "track",
+            sentAt: new Date(),
+        };
+        const buffer = new events_1.EventBuffer(mockEventsApi, {
+            logger: mockLogger,
+            maxSize: 1,
+            interval: 1000,
+        });
+        yield buffer.push(event1);
+        expect(mockEventsApi.createEventBatch).not.toHaveBeenCalled();
+        // Force first flush by exceeding max size
+        yield buffer.push(event2);
+        expect(mockEventsApi.createEventBatch).toHaveBeenCalledTimes(1);
+        expect(mockEventsApi.createEventBatch).toHaveBeenCalledWith({
+            events: [event1],
+        });
+        // Wait for the next periodic flush
+        jest.advanceTimersByTime(1001);
+        expect(mockEventsApi.createEventBatch).toHaveBeenCalledTimes(2);
+        expect(mockEventsApi.createEventBatch).toHaveBeenCalledWith({
+            events: [event2],
+        });
+    }));
+    // The rest of the tests remain unchanged as they don't directly test the maxSize behavior
+    it("should log error if flushing fails", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockEventsApi.createEventBatch.mockRejectedValue(new Error("Flush error"));
+        const buffer = new events_1.EventBuffer(mockEventsApi, {
+            logger: mockLogger,
+            interval: 1000,
+        });
+        const event = {
+            body: {
+                company: { id: "test-company" },
+                event: "test-event",
+                user: { id: "test-user" },
+            },
+            eventType: "track",
+            sentAt: new Date(),
+        };
+        yield buffer.push(event);
+        yield buffer.push(event);
+        // Manually trigger flush
+        yield buffer.flush();
+        expect(mockLogger.error).toHaveBeenCalledWith("Failed to flush events", expect.any(Error));
+    }));
+    it("should stop accepting events after stop is called", () => __awaiter(void 0, void 0, void 0, function* () {
+        const buffer = new events_1.EventBuffer(mockEventsApi, {
+            interval: 1000,
+            logger: mockLogger,
+        });
+        const event = {
+            body: {
+                company: { id: "test-company" },
+                event: "test-event",
+                user: { id: "test-user" },
+            },
+            eventType: "track",
+            sentAt: new Date(),
+        };
+        yield buffer.push(event);
+        yield buffer.stop();
+        yield buffer.push(event);
+        expect(mockLogger.error).toHaveBeenCalledWith("Event buffer is stopped, not accepting new events");
+        expect(mockEventsApi.createEventBatch).toHaveBeenCalledTimes(1);
+    }));
+    it("should periodically flush events", () => __awaiter(void 0, void 0, void 0, function* () {
+        const buffer = new events_1.EventBuffer(mockEventsApi, {
+            interval: 1000,
+            logger: mockLogger,
+        });
+        const event = {
+            body: {
+                company: { id: "test-company" },
+                event: "test-event",
+                user: { id: "test-user" },
+            },
+            eventType: "track",
+            sentAt: new Date(),
+        };
+        yield buffer.push(event);
+        jest.advanceTimersByTime(1000);
+        expect(mockEventsApi.createEventBatch).toHaveBeenCalledTimes(1);
+        expect(mockEventsApi.createEventBatch).toHaveBeenCalledWith({
+            events: [event],
+        });
+    }));
+    it("should not flush events if shutdown", () => __awaiter(void 0, void 0, void 0, function* () {
+        const buffer = new events_1.EventBuffer(mockEventsApi, {
+            interval: 1000,
+            logger: mockLogger,
+        });
+        const event = {
+            body: {
+                company: { id: "test-company" },
+                event: "test-event",
+                user: { id: "test-user" },
+            },
+            eventType: "track",
+            sentAt: new Date(),
+        };
+        yield buffer.push(event);
+        buffer["shutdown"] = true;
+        jest.advanceTimersByTime(1000);
+        expect(mockEventsApi.createEventBatch).not.toHaveBeenCalled();
+    }));
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * as Schematic from "./api";
+export { LocalCache } from "./cache";
+export { SchematicClient } from "./wrapper";
+export { SchematicEnvironment } from "./environments";
+export { SchematicError, SchematicTimeoutError } from "./errors";

package/dist/index.js

@@ -0,0 +1,36 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchematicTimeoutError = exports.SchematicError = exports.SchematicEnvironment = exports.SchematicClient = exports.LocalCache = exports.Schematic = void 0;
+exports.Schematic = __importStar(require("./api"));
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "LocalCache", { enumerable: true, get: function () { return cache_1.LocalCache; } });
+var wrapper_1 = require("./wrapper");
+Object.defineProperty(exports, "SchematicClient", { enumerable: true, get: function () { return wrapper_1.SchematicClient; } });
+var environments_1 = require("./environments");
+Object.defineProperty(exports, "SchematicEnvironment", { enumerable: true, get: function () { return environments_1.SchematicEnvironment; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "SchematicError", { enumerable: true, get: function () { return errors_1.SchematicError; } });
+Object.defineProperty(exports, "SchematicTimeoutError", { enumerable: true, get: function () { return errors_1.SchematicTimeoutError; } });

package/dist/logger.d.ts

@@ -0,0 +1,13 @@
+export interface Logger {
+    error(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+}
+declare class ConsoleLogger implements Logger {
+    error(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+}
+export { ConsoleLogger };

package/dist/logger.js

@@ -0,0 +1,19 @@
+"use strict";
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+class ConsoleLogger {
+    error(message, ...args) {
+        console.error(message, ...args);
+    }
+    warn(message, ...args) {
+        console.warn(message, ...args);
+    }
+    info(message, ...args) {
+        console.info(message, ...args);
+    }
+    debug(message, ...args) {
+        console.debug(message, ...args);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;

package/dist/serialization/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./resources";
+export * from "./types";

package/dist/serialization/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("./resources"), exports);
+__exportStar(require("./types"), exports);

package/dist/serialization/resources/accesstokens/client/index.d.ts

@@ -0,0 +1 @@
+export * from "./requests";

package/dist/serialization/resources/accesstokens/client/index.js

@@ -0,0 +1,17 @@
+"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("./requests"), exports);

package/dist/serialization/resources/accesstokens/client/requests/IssueTemporaryAccessTokenRequestBody.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../../../../index";
+import * as Schematic from "../../../../../api/index";
+import * as core from "../../../../../core";
+export declare const IssueTemporaryAccessTokenRequestBody: core.serialization.Schema<serializers.IssueTemporaryAccessTokenRequestBody.Raw, Schematic.IssueTemporaryAccessTokenRequestBody>;
+export declare namespace IssueTemporaryAccessTokenRequestBody {
+    interface Raw {
+        lookup: Record<string, string>;
+        resource_type: string;
+    }
+}