@jd-data-limited/easy-fm 4.1.15 → 5.0.0-beta.2

package/dist/connection/database.js

@@ -1,106 +1,48 @@
 /*
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
-import { EventEmitter } from 'events';
-import { generateAuthorizationHeaders } from './generateAuthorizationHeaders.js';
 import { FMError } from '../FMError.js';
 import { Layout } from '../layouts/layout.js';
-import fetch from 'node-fetch';
-// @ts-expect-error - fetchWithCookies does not have available typescript types
-import fetchWithCookies, { CookieJar } from 'node-fetch-cookies';
+import { ApiLayout, ApiResults } from '../models/apiResults.js';
+import { z } from 'zod';
+import { addHeaders } from '../utils/addHeaders.js';
+import process from 'node:process';
 /**
  * Represents a database connection.
  * @template T - The structure of the database.
  */
-export class Database extends EventEmitter {
-    _token = '';
+export class Database {
     host;
-    connection_details;
-    cookies = new CookieJar();
     name;
     debug;
     #layoutCache = new Map();
+    canOpenNewConnections = true;
+    /**
+     * Used during events where the application must logout
+     * @private
+     */
+    abortController = new AbortController();
     constructor(host, conn) {
-        super();
         this.host = host;
         this.name = conn.database;
-        this.connection_details = conn;
         this.debug = conn.debug ?? false;
+        process.on('SIGINT', () => { void this.close(); });
+        process.on('SIGTERM', () => { void this.close(); });
+        process.on('beforeExit', () => { void this.close(); });
     }
-    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    generateExternalSourceLogin(data) {
-        if (data.credentials.method === 'filemaker') {
-            const _data = data.credentials;
-            return {
-                database: data.database,
-                username: _data.username,
-                password: _data.password
-            };
-        }
-        else {
-            throw new Error('Not yet supported login method');
-        }
+    async login() {
+        await Promise.resolve();
     }
-    /**
-     * Logs out the user by deleting the current session token.
-     * Throws an error if the user is not logged in.
-     *
-     * @returns {Promise<void>} A promise that resolves with no value once the logout is successful.
-     * @throws {Error} Throws an error if the user is not logged in.
-     */
     async logout() {
-        if (this.token === '')
-            throw new Error('Not logged in');
-        const _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
-            method: 'DELETE',
-            headers: {
-                'content-type': 'application/json'
-            }
-        });
-        await _fetch.json();
-        this._token = '';
+        await this.close();
     }
-    /**
-     * Logs in to the database. Not required, as this is often done automatically
-     *
-     * @param {boolean} [forceLogin=false] - Whether to force login even if already logged in.
-     * @throws {Error} - Throws an error if already logged in and forceLogin is false.
-     * @throws {FMError} - Throws an FMError if login fails.
-     * @return {Promise<string>} - Returns a promise that resolves to the access token upon successful login.
-     */
-    async login(forceLogin = false) {
-        if (this.token !== '' && !forceLogin)
-            return;
-        // Reset cookies
-        this.cookies = new CookieJar();
-        await this.host.getMetadata();
-        if (this.connection_details.credentials.method === 'token') {
-            this._token = (this.connection_details.credentials).token;
-            return this.token;
-        }
-        const url = new URL(`${this.endpoint}/sessions`);
-        url.hostname = this.host.hostname;
-        const res = await fetch(url, {
-            method: 'POST',
-            headers: generateAuthorizationHeaders(this.connection_details.credentials),
-            body: JSON.stringify({
-                fmDataSource: this.connection_details.externalSources.map(i => {
-                    const _i = i;
-                    return this.generateExternalSourceLogin(_i);
-                })
-            })
-        });
-        const _res = (await res.json());
-        if (res.status === 200) {
-            this._token = res.headers.get('x-fm-data-access-token') ?? '';
-            return this._token;
-        }
-        else {
-            throw new FMError(_res.messages[0].code, _res.status, res);
-        }
+    async close() {
+        this.canOpenNewConnections = false;
+        if (!this.abortController.signal.aborted)
+            this.abortController.abort('Closing connection');
     }
-    get token() {
-        return this._token;
+    async [Symbol.asyncDispose]() {
+        await this.close();
     }
     /**
      * Returns the endpoint URL for the database connection.
@@ -110,57 +52,49 @@ export class Database extends EventEmitter {
     get endpoint() {
         return `${this.host.protocol}//${this.host.hostname}/fmi/data/v2/databases/${this.name}`;
     }
-    async _apiRequestRaw(url, options = {}, autoRelogin = true) {
-        if (this.debug) {
-            console.log(`EASYFM DEBUG: ${JSON.stringify(options)} ${url instanceof URL
-                ? url.toString()
-                : typeof url === 'string' ? url : url.url}`);
-        }
-        const urlParsed = (url instanceof URL
-            ? url
-            : typeof url === 'string'
-                ? new URL(url)
-                : new URL(url.url));
-        const reqIsToDBHost = urlParsed.hostname === this.host.hostname && urlParsed.pathname.startsWith("/fmi/data");
-        if (reqIsToDBHost && this.token === '')
-            await this.login(true);
-        if (!options.headers)
-            options.headers = {};
-        if (reqIsToDBHost)
-            options.headers.authorization = 'Bearer ' + this._token;
-        const _fetch = options.useCookieJar
-            ? await fetchWithCookies(this.cookies, url, options)
-            : await fetch(url, options);
-        if (!_fetch.ok && (!options.retries || options.retries > 0)) {
-            if (this.debug) {
-                console.log(`EASYFM DEBUG: RE-ATTEMPTING REQUEST (${_fetch.status}) ${url instanceof URL
-                    ? url.toString()
-                    : typeof url === 'string' ? url : url.url}`);
+    /**
+     * Uses an available session to run a fetch
+     * @param url
+     * @param options
+     */
+    async fetch(url, options) {
+        return await this.withSession(async (session) => await session.fetch(url, options));
+    }
+    /**
+     * Uses an available session to run a fetch on a FileMaker Data API JSON endpoint. Also applies JSON/Zod type enforcement on result.
+     */
+    async fetchJSON(url, options) {
+        const _options = options ?? {};
+        addHeaders(_options, {
+            'Content-Type': 'application/json'
+        });
+        const res = await this.fetch(url, _options);
+        const rawData = await res.json();
+        if (this.debug)
+            console.log(rawData.response);
+        if (options.type !== null) {
+            const data = ApiResults.extend({ response: options.type.optional() })
+                .parse(rawData);
+            if (data.messages[0].code !== 0) {
+                throw new FMError(data.messages[0].code, res.status, data);
             }
-            return await this._apiRequestRaw(url, { ...options, retries: (options?.retries ?? 1) - 1 });
-        }
-        else if (_fetch.status === 401 && reqIsToDBHost && autoRelogin) {
-            await this.login(true);
-            return await this._apiRequestRaw(url, options, false);
+            return data.response
+                // @ts-expect-error is correct
+                ? {
+                    ...data.response,
+                    httpStatus: res.status
+                }
+                // @ts-expect-error is correct
+                : { httpStatus: res.status };
         }
-        else
-            return _fetch;
-    }
-    async _apiRequestJSON(url, options = {}) {
-        if (!options.headers)
-            options.headers = {};
-        options.headers['content-type'] = options.headers['content-type'] ? options.headers['content-type'] : 'application/json';
-        const _fetch = await this._apiRequestRaw(url, options);
-        const data = await _fetch.json();
-        // Remove response if it is empty. This makes checking for an empty response easier
-        if (data.response && Object.keys(data.response).length === 0)
-            delete data.response;
-        // console.log(data.messages[0])
-        if (data.messages[0].code !== '0') {
-            throw new FMError(data.messages[0].code, _fetch.status, data);
+        const data = ApiResults.parse(rawData);
+        if (data.messages[0].code !== 0) {
+            throw new FMError(data.messages[0].code, res.status, data);
         }
-        data.httpStatus = _fetch.status;
-        return data;
+        // @ts-expect-error is correct
+        return {
+            httpStatus: res.status
+        };
     }
     /**
      * Retrieves a list of layouts in the current FileMaker database.
@@ -169,9 +103,9 @@ export class Database extends EventEmitter {
      * @throws {FMError} If there was an error retrieving the layouts.
      */
     async listLayouts(page = 0) {
-        const req = await this._apiRequestJSON(`${this.endpoint}/layouts?page=${encodeURIComponent(page)}`);
-        if (!req.response)
-            throw new FMError(req.messages[0].code, req.httpStatus, req.messages[0].message);
+        const res = await this.fetchJSON(`${this.endpoint}/layouts?page=${encodeURIComponent(page)}`, {
+            type: z.object({ layouts: z.array(ApiLayout) })
+        });
         const cycleLayoutNames = (layouts) => {
             let names = [];
             for (const layout of layouts) {
@@ -182,8 +116,11 @@ export class Database extends EventEmitter {
             }
             return names;
         };
-        return cycleLayoutNames(req.response.layouts).map(layout => new Layout(this, layout));
+        return cycleLayoutNames(res.layouts).map(layout => new Layout(this, layout));
     }
+    /**
+     * Returns a FileMaker Layout object by name.
+     */
     layout(name) {
         let layout = this.#layoutCache.get(name);
         if (layout)
@@ -192,9 +129,11 @@ export class Database extends EventEmitter {
         this.#layoutCache.set(name, layout);
         return layout;
     }
+    /** Clears any Layout objects previously returned by `database.layout(...)`. */
     clearLayoutCache() {
         this.#layoutCache.clear();
     }
+    /** Creates a script reference you can pass to read and write helpers. */
     script(name, parameter = '') {
         return { name, parameter };
     }

package/dist/connection/databaseBase.d.ts

@@ -1,16 +1,28 @@
 import { type HostBase } from './HostBase.js';
-import { type ApiResults } from '../models/apiResults.js';
-import { type RequestInfo, type RequestInit, type Response } from 'node-fetch';
+import { type z, type ZodType } from 'zod';
 export interface DatabaseBase {
     host: HostBase;
     readonly name: string;
     endpoint: string;
-    token: string;
-    _apiRequestJSON: <T = unknown>(url: URL | RequestInfo, options?: RequestInit & {
-        headers?: Record<string, string>;
-    } | undefined, autoRelogin?: boolean) => Promise<ApiResults<T>>;
-    _apiRequestRaw: (url: URL | RequestInfo, options?: RequestInit & {
-        headers?: Record<string, string>;
-        useCookieJar?: boolean;
-    } | undefined) => Promise<Response>;
+    /**
+     * @deprecated login is deprecated and is now handled by newer session management. This function is simply a placeholder.
+     */
+    login: () => Promise<void>;
+    /**
+     * Immediately closes all open sessions and prevents new ones from being created.
+     */
+    close: () => Promise<void>;
+    /**
+     * Immediately closes all open sessions and prevents new ones from being created.
+     * Alias of {@link close}
+     */
+    logout: () => Promise<void>;
+    fetch: (url: string | URL, options?: RequestInit) => Promise<Response>;
+    fetchJSON: <T extends ZodType | null = null>(url: string | URL, options: RequestInit & {
+        type: T;
+    }) => Promise<T extends ZodType ? z.infer<T> & {
+        httpStatus: number;
+    } : {
+        httpStatus: number;
+    }>;
 }

package/dist/connection/databaseConstantSession.d.ts

@@ -0,0 +1,15 @@
+import { Database } from './database.js';
+import type { DatabaseStructure } from '../databaseStructure.js';
+import { type Session } from './Session.js';
+import { type databaseOptionsWithExternalSources, type loginOptionsClaris, type loginOptionsOAuth, type loginOptionsToken } from '../types.js';
+import type FMHost from './FMHost.js';
+/**
+ * DatabaseConstantSession handles database connections that must live on a single session which is kept alive.
+ * For example, connections that rely on OAuth.
+ */
+export declare class DatabaseConstantSession<T extends DatabaseStructure> extends Database<T> {
+    #private;
+    constructor(host: FMHost, connectionDetails: databaseOptionsWithExternalSources<loginOptionsOAuth | loginOptionsClaris | loginOptionsToken>, structure: T);
+    close(): Promise<void>;
+    withSession<T>(callback: (session: Session) => Promise<T>): Promise<T>;
+}

package/dist/connection/databaseConstantSession.js

@@ -0,0 +1,70 @@
+import { Database } from './database.js';
+import { session } from './Session.js';
+import { generateAuthorizationHeaders } from './generateAuthorizationHeaders.js';
+import { FMError } from '../FMError.js';
+import { ApiResults } from '../models/apiResults.js';
+import { CookieJar } from './CookieJar.js';
+/**
+ * DatabaseConstantSession handles database connections that must live on a single session which is kept alive.
+ * For example, connections that rely on OAuth.
+ */
+export class DatabaseConstantSession extends Database {
+    #session;
+    constructor(host, connectionDetails, structure) {
+        super(host, connectionDetails);
+        if (connectionDetails.externalSources.length !== 0)
+            throw new Error('External sources are currently only supported for connections with the \'FileMaker\' login method.');
+        this.#session = (async () => {
+            // Ensure we have host metadata
+            await this.host.getMetadata();
+            if (connectionDetails.credentials.method === 'token') {
+                return session({
+                    token: (connectionDetails.credentials).token,
+                    keepAlive: 60_000,
+                    endpoint: this.endpoint,
+                    abortSignal: this.abortController.signal
+                });
+            }
+            const url = new URL(`${this.endpoint}/sessions`);
+            url.hostname = this.host.hostname;
+            const cookiejar = new CookieJar();
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: generateAuthorizationHeaders(connectionDetails.credentials),
+                body: JSON.stringify({
+                    fmDataSource: connectionDetails.externalSources.map(data => ({
+                        database: data.database,
+                        username: data.credentials.username,
+                        password: data.credentials.password
+                    }))
+                })
+            });
+            for (const cookie of res.headers.getSetCookie())
+                cookiejar.addCookie(url, cookie);
+            const json = ApiResults.parse(await res.json());
+            if (res.status === 200) {
+                return session({
+                    token: res.headers.get('x-fm-data-access-token') ?? '',
+                    keepAlive: 60_000,
+                    endpoint: this.endpoint,
+                    baseCookieJar: cookiejar,
+                    abortSignal: this.abortController.signal
+                });
+            }
+            else {
+                throw new FMError(json.messages[0].code, res.status, res);
+            }
+        })();
+    }
+    async close() {
+        if (this.abortController.signal.aborted)
+            return;
+        await super.close();
+        await (await this.#session).logout();
+    }
+    async withSession(callback) {
+        if (!this.canOpenNewConnections)
+            throw new Error('Cannot open new connections');
+        return await callback(await this.#session);
+    }
+}

package/dist/connection/databaseSessionPool.d.ts

@@ -0,0 +1,14 @@
+import { Database } from './database.js';
+import type { DatabaseStructure } from '../databaseStructure.js';
+import { type Session } from './Session.js';
+import { type databaseOptionsWithExternalSources, type loginOptionsFileMaker } from '../types.js';
+import type FMHost from './FMHost.js';
+/**
+ * DatabaseSessionPool handles database connections that can be pooled.
+ */
+export declare class DatabaseSessionPool<T extends DatabaseStructure> extends Database<T> {
+    #private;
+    constructor(host: FMHost, connectionDetails: databaseOptionsWithExternalSources<loginOptionsFileMaker>);
+    close(): Promise<void>;
+    withSession<T>(callback: (session: Session) => Promise<T>, retry?: boolean): Promise<T>;
+}

package/dist/connection/databaseSessionPool.js

@@ -0,0 +1,148 @@
+import { Database } from './database.js';
+import { HttpError, session } from './Session.js';
+import { generateAuthorizationHeaders } from './generateAuthorizationHeaders.js';
+import { FMError } from '../FMError.js';
+import { ApiResults } from '../models/apiResults.js';
+import { CookieJar } from './CookieJar.js';
+/**
+ * DatabaseSessionPool handles database connections that can be pooled.
+ */
+export class DatabaseSessionPool extends Database {
+    #connectionDetails;
+    #activeSessions = new Set();
+    #withSessionQueue = [];
+    constructor(host, connectionDetails) {
+        super(host, connectionDetails);
+        this.#connectionDetails = connectionDetails;
+    }
+    async close() {
+        if (this.abortController.signal.aborted)
+            return;
+        await super.close();
+        // System might be shutting down, so we want to make sure we're quick
+        const sessions = [...this.#activeSessions];
+        this.#activeSessions.clear();
+        await Promise.allSettled(sessions.map(session => session.session.logout()));
+    }
+    get #maxSessions() {
+        return this.#connectionDetails.credentials.sessionPoolSize ?? 8;
+    }
+    // Opens a new database session
+    async #openSession() {
+        if (!this.canOpenNewConnections)
+            throw new Error('Cannot open new connections');
+        await this.host.getMetadata();
+        const url = new URL(`${this.endpoint}/sessions`);
+        url.hostname = this.host.hostname;
+        const cookiejar = new CookieJar();
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: generateAuthorizationHeaders(this.#connectionDetails.credentials),
+            body: JSON.stringify({
+                fmDataSource: this.#connectionDetails.externalSources.map(data => ({
+                    database: data.database,
+                    username: data.credentials.username,
+                    password: data.credentials.password
+                }))
+            })
+        });
+        for (const cookie of res.headers.getSetCookie())
+            cookiejar.addCookie(url, cookie);
+        const _res = ApiResults.parse(await res.json());
+        if (res.status === 200) {
+            return session({
+                token: res.headers.get('x-fm-data-access-token') ?? '',
+                endpoint: this.endpoint,
+                baseCookieJar: cookiejar,
+                abortSignal: this.abortController.signal
+            });
+        }
+        else {
+            throw new FMError(_res.messages[0].code, res.status, res);
+        }
+    }
+    /**
+     *
+     * @param session
+     * @param callback
+     * @param retry when true, if an HTTP 401 error occurs, we'll re-attempt it with another session.
+     * @private
+     */
+    async #withSessionInternal(session, callback, retry) {
+        try {
+            session.working = true;
+            const result = await callback(session.session);
+            return result;
+        }
+        catch (e) {
+            if (e instanceof HttpError && e.status === 401) {
+                // Invalidate this session
+                this.#activeSessions.delete(session);
+                if (retry)
+                    return await this.withSession(callback, false);
+            }
+            throw e;
+        }
+        finally {
+            if (this.#activeSessions.has(session)) {
+                session.working = false;
+            }
+            await this.#scheduleQueuedWork();
+        }
+    }
+    async #processWithSessionQueue(session) {
+        const job = this.#withSessionQueue.shift();
+        if (!job)
+            return;
+        await this.#withSessionInternal(session, job.callback, job.retry).then(job.resolve).catch(job.reject);
+    }
+    async #scheduleQueuedWork() {
+        if (this.#withSessionQueue.length === 0)
+            return;
+        for (const session of this.#activeSessions) {
+            if (!session.working) {
+                session.working = true;
+                void this.#processWithSessionQueue(session);
+                return;
+            }
+        }
+        if (this.#activeSessions.size < this.#maxSessions) {
+            void this.#openSession().then(async (session) => {
+                const newSession = {
+                    working: true,
+                    session,
+                    disconnectTimeout: null
+                };
+                this.#activeSessions.add(newSession);
+                await this.#processWithSessionQueue(newSession);
+            });
+        }
+    }
+    async withSession(callback, retry = true) {
+        return await new Promise((resolve, reject) => {
+            // First, see if there's an available session
+            for (const session of this.#activeSessions) {
+                if (!session.working) {
+                    session.working = true;
+                    this.#withSessionInternal(session, callback, retry).then(resolve).catch(reject);
+                    return;
+                }
+            }
+            // If there's no available sessions, next check if we can open a new one
+            if (this.#activeSessions.size < this.#maxSessions) {
+                this.#openSession().then(async (session) => {
+                    const newSession = {
+                        working: true,
+                        session,
+                        disconnectTimeout: null
+                    };
+                    this.#activeSessions.add(newSession);
+                    return await this.#withSessionInternal(newSession, callback, retry);
+                }).then(resolve).catch(reject);
+                return;
+            }
+            // Finally if all else fails, queue the job
+            this.#withSessionQueue.push({ callback, resolve, reject, retry });
+        });
+    }
+}

package/dist/index.d.ts

@@ -1,18 +1,38 @@
 import FMHost from './connection/FMHost.js';
 import type * as TYPES from './types.js';
+/** Error type returned for FileMaker Data API failures. */
 export { FMError } from './FMError.js';
+/** Utility type for narrowing portal data on typed layouts. */
 export { type PickPortals } from './types.js';
+/** Base database connection abstraction used by all auth modes. */
 export { Database } from './connection/database.js';
+/** Layout-scoped API wrapper for metadata, scripts, and record operations. */
 export { Layout } from './layouts/layout.js';
+/** Base record implementation shared by layout and portal records. */
 export { RecordBase } from './records/recordBase.js';
+/** Record returned from a layout. Supports fetch, commit, duplicate, and delete. */
 export { LayoutRecord } from './records/layoutRecord.js';
-export { type LayoutInterface, type PortalInterface } from './layouts/layoutInterface.js';
+/** Type helpers for describing typed layouts and portals. */
+export { type LayoutInterface, type PortalInterface, type RecordFieldsMap } from './layouts/layoutInterface.js';
+/** Record returned from a portal row. */
 export { PortalRecord } from './records/portalRecord.js';
+/** Wrapper around portal rows included in a layout record. */
 export { Portal } from './records/portal.js';
+/** Types and builder used for list/find record operations. */
 export { type FindRequest, type FindRequestRaw, RecordGetOperation } from './records/getOperations/recordGetOperation.js';
+/** Entry point for `layout.records.*` operations. */
 export { LayoutRecordManager } from './layouts/layoutRecordManager.js';
-export { type RecordFieldsMap } from './layouts/recordFieldsMap.js';
+/** Helpers for safe FileMaker find query construction and date/time formatting. */
 export { asDate, asTime, asTimestamp, query, queryEscape } from './utils/query.js';
-export { type Container, Field } from './records/field.js';
+/** Conversion helpers for FileMaker-formatted Temporal values. */
+export * from './records/fields/valueField.js';
+export * from './records/fields/containerField.js';
+export { type Field } from './records/fields/field.js';
+export { stringToTemporal, temporalToString, type TemporalValue, type TemporalValueType } from './utils/temporal.js';
+/** Field wrapper used for reading, editing, and container access. */
+export { type BaseField } from './records/fields/baseField.js';
+/** Default export. Represents FileMaker host/server. */
 export default FMHost;
-export { type TYPES };
+export { 
+/** Namespace re-export of library public types. */
+type TYPES };

package/dist/index.js

@@ -2,15 +2,29 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 import FMHost from './connection/FMHost.js';
+/** Error type returned for FileMaker Data API failures. */
 export { FMError } from './FMError.js';
+/** Base database connection abstraction used by all auth modes. */
 export { Database } from './connection/database.js';
+/** Layout-scoped API wrapper for metadata, scripts, and record operations. */
 export { Layout } from './layouts/layout.js';
+/** Base record implementation shared by layout and portal records. */
 export { RecordBase } from './records/recordBase.js';
+/** Record returned from a layout. Supports fetch, commit, duplicate, and delete. */
 export { LayoutRecord } from './records/layoutRecord.js';
+/** Record returned from a portal row. */
 export { PortalRecord } from './records/portalRecord.js';
+/** Wrapper around portal rows included in a layout record. */
 export { Portal } from './records/portal.js';
+/** Types and builder used for list/find record operations. */
 export { RecordGetOperation } from './records/getOperations/recordGetOperation.js';
+/** Entry point for `layout.records.*` operations. */
 export { LayoutRecordManager } from './layouts/layoutRecordManager.js';
+/** Helpers for safe FileMaker find query construction and date/time formatting. */
 export { asDate, asTime, asTimestamp, query, queryEscape } from './utils/query.js';
-export { Field } from './records/field.js';
+/** Conversion helpers for FileMaker-formatted Temporal values. */
+export * from './records/fields/valueField.js';
+export * from './records/fields/containerField.js';
+export { stringToTemporal, temporalToString } from './utils/temporal.js';
+/** Default export. Represents FileMaker host/server. */
 export default FMHost;

package/dist/layouts/layout.d.ts

@@ -3,13 +3,15 @@ import { type Script, type ScriptResult } from '../types.js';
 import { type LayoutInterface } from './layoutInterface.js';
 import { type LayoutBase } from './layoutBase.js';
 import { type DatabaseBase } from '../connection/databaseBase.js';
-import { type ApiLayoutMetadata } from '../models/apiResults.js';
+import { ApiLayoutMetadata } from '../models/apiResults.js';
+import { type z } from 'zod';
 export declare class Layout<T extends LayoutInterface> implements LayoutBase {
     readonly database: DatabaseBase;
     readonly name: string;
     readonly records: LayoutRecordManager<T>;
-    metadata: ApiLayoutMetadata | null;
+    metadata: z.infer<typeof ApiLayoutMetadata> | null;
     constructor(database: DatabaseBase, name: string);
+    /** Base endpoint for this layout on FileMaker Data API. */
     get endpoint(): string;
     /**
      * Executes a FileMaker script on this layout asynchronously and returns the result.
@@ -23,5 +25,5 @@ export declare class Layout<T extends LayoutInterface> implements LayoutBase {
      * @returns {Promise<ApiLayoutMetadata>} The layout metadata.
      * @throws {FMError} If an error occurs during the API request.
      */
-    getLayoutMeta(): Promise<ApiLayoutMetadata>;
+    getLayoutMeta(): Promise<z.infer<typeof ApiLayoutMetadata>>;
 }