fms-odata-js 0.3.0 → 0.4.1

package/dist/fms-odata.esm.js

@@ -62,7 +62,7 @@ function isFMScriptError(err) {
 }
 
 // src/http.ts
-var AUTH_SCHEME_RE = /^(basic|bearer|fmid|negotiate|digest)\s+\S/i;
+var AUTH_SCHEME_RE = /^(basic|bearer|negotiate|digest)\s+\S/i;
 async function resolveAuthHeader(provider) {
   const raw = typeof provider === "function" ? await provider() : provider;
   if (typeof raw !== "string" || raw.length === 0) {
@@ -75,8 +75,8 @@ function basicAuth(user, password) {
   const b64 = typeof Buffer !== "undefined" ? Buffer.from(raw, "utf8").toString("base64") : btoa(unescape(encodeURIComponent(raw)));
   return `Basic ${b64}`;
 }
-function fmidAuth(token) {
-  return `FMID ${token}`;
+function bearerAuth(token) {
+  return `Bearer ${token}`;
 }
 function combineSignals(signals) {
   const filtered = signals.filter((s) => s !== void 0);
@@ -515,20 +515,21 @@ var Batch = class {
 
 // node_modules/@fms-odata/spec-ts/dist/versions.js
 var FM_VERSION_NAMES = {
-  "19": "FileMaker 19.x",
-  "21": "Claris FileMaker 2023",
-  "22": "Claris FileMaker 2024",
+  "20": "Claris FileMaker 2023",
+  "21": "Claris FileMaker 2024",
+  "22": "Claris FileMaker 2025",
   "26": "Claris FileMaker 2026",
   future: "Future / next"
 };
-var ODATA_PROTOCOL_VERSION = "4.0";
+var ODATA_PROTOCOL_VERSION = "4.01";
 var FM_VERSION_MATRIX = {
-  "19": {
-    major: "19",
-    name: "FileMaker 19.x",
-    releaseYear: null,
-    internalVersion: "19.x",
-    status: "baseline",
+  "20": {
+    major: "20",
+    name: "Claris FileMaker 2023",
+    releaseYear: 2023,
+    internalVersion: "20.x",
+    status: "supported",
+    odataProtocolVersion: "4.0",
     features: {
       serviceDocument: true,
       metadata: true,
@@ -550,12 +551,17 @@ var FM_VERSION_MATRIX = {
       applyAggregation: false,
       typeCasting: false,
       parameterizedFilters: false,
+      simplifiedQuerySyntax: false,
+      nestedQueries: false,
+      batchPreferenceInheritance: false,
+      metadataFiltering: false,
       immutableIdUrls: false,
+      fmComment: false,
       aiAnnotation: false,
+      computedAnnotation: false,
       serverVersionAnnotation: false,
       enrichedFMComment: false,
       authBasic: true,
-      authFMID: false,
       authOAuth: false
     },
     queryOptions: {
@@ -573,10 +579,11 @@ var FM_VERSION_MATRIX = {
   },
   "21": {
     major: "21",
-    name: "Claris FileMaker 2023",
-    releaseYear: 2023,
+    name: "Claris FileMaker 2024",
+    releaseYear: 2024,
     internalVersion: "21.x",
     status: "supported",
+    odataProtocolVersion: "4.01",
     features: {
       serviceDocument: true,
       metadata: true,
@@ -587,23 +594,28 @@ var FM_VERSION_MATRIX = {
       crossJoin: true,
       batch: true,
       scripts: true,
-      scriptsByFMSID: false,
+      scriptsByFMSID: true,
       scriptListing: false,
       containerBinaryUpload: true,
       containerBase64Upload: true,
       containerDownload: true,
       schemaModification: true,
-      webhooks: true,
+      webhooks: false,
       webhookQueryHeaders: false,
       applyAggregation: false,
       typeCasting: true,
       parameterizedFilters: true,
+      simplifiedQuerySyntax: true,
+      nestedQueries: true,
+      batchPreferenceInheritance: true,
+      metadataFiltering: false,
       immutableIdUrls: false,
-      aiAnnotation: false,
+      fmComment: true,
+      aiAnnotation: true,
+      computedAnnotation: false,
       serverVersionAnnotation: false,
       enrichedFMComment: false,
       authBasic: true,
-      authFMID: true,
       authOAuth: true
     },
     queryOptions: {
@@ -621,10 +633,11 @@ var FM_VERSION_MATRIX = {
   },
   "22": {
     major: "22",
-    name: "Claris FileMaker 2024",
-    releaseYear: 2024,
+    name: "Claris FileMaker 2025",
+    releaseYear: 2025,
     internalVersion: "22.x",
     status: "supported",
+    odataProtocolVersion: "4.01",
     features: {
       serviceDocument: true,
       metadata: true,
@@ -635,7 +648,7 @@ var FM_VERSION_MATRIX = {
       crossJoin: true,
       batch: true,
       scripts: true,
-      scriptsByFMSID: false,
+      scriptsByFMSID: true,
       scriptListing: false,
       containerBinaryUpload: true,
       containerBase64Upload: true,
@@ -646,12 +659,17 @@ var FM_VERSION_MATRIX = {
       applyAggregation: true,
       typeCasting: true,
       parameterizedFilters: true,
+      simplifiedQuerySyntax: true,
+      nestedQueries: true,
+      batchPreferenceInheritance: true,
+      metadataFiltering: true,
       immutableIdUrls: false,
-      aiAnnotation: false,
+      fmComment: true,
+      aiAnnotation: true,
+      computedAnnotation: false,
       serverVersionAnnotation: false,
       enrichedFMComment: false,
       authBasic: true,
-      authFMID: true,
       authOAuth: true
     },
     queryOptions: {
@@ -673,6 +691,7 @@ var FM_VERSION_MATRIX = {
     releaseYear: 2026,
     internalVersion: "26.x",
     status: "current",
+    odataProtocolVersion: "4.01",
     features: {
       serviceDocument: true,
       metadata: true,
@@ -694,12 +713,17 @@ var FM_VERSION_MATRIX = {
       applyAggregation: true,
       typeCasting: true,
       parameterizedFilters: true,
+      simplifiedQuerySyntax: true,
+      nestedQueries: true,
+      batchPreferenceInheritance: true,
+      metadataFiltering: true,
       immutableIdUrls: true,
+      fmComment: true,
       aiAnnotation: true,
+      computedAnnotation: true,
       serverVersionAnnotation: true,
       enrichedFMComment: true,
       authBasic: true,
-      authFMID: true,
       authOAuth: true
     },
     queryOptions: {
@@ -721,6 +745,7 @@ var FM_VERSION_MATRIX = {
     releaseYear: null,
     internalVersion: "unknown",
     status: "future",
+    odataProtocolVersion: "4.01",
     features: {
       serviceDocument: true,
       metadata: true,
@@ -742,12 +767,17 @@ var FM_VERSION_MATRIX = {
       applyAggregation: true,
       typeCasting: true,
       parameterizedFilters: true,
+      simplifiedQuerySyntax: true,
+      nestedQueries: true,
+      batchPreferenceInheritance: true,
+      metadataFiltering: true,
       immutableIdUrls: true,
+      fmComment: true,
       aiAnnotation: true,
+      computedAnnotation: true,
       serverVersionAnnotation: true,
       enrichedFMComment: true,
       authBasic: true,
-      authFMID: true,
       authOAuth: true
     },
     queryOptions: {
@@ -771,7 +801,7 @@ function hasQueryOption(version, option) {
   return FM_VERSION_MATRIX[version]?.queryOptions[option] ?? false;
 }
 function minVersionForFeature(feature) {
-  const order = ["19", "21", "22", "26"];
+  const order = ["20", "21", "22", "26"];
   for (const v of order) {
     if (FM_VERSION_MATRIX[v].features[feature])
       return v;
@@ -827,6 +857,43 @@ function parseServerVersion(metadataXml) {
   return null;
 }
 
+// node_modules/@fms-odata/spec-ts/dist/schema.js
+var FIELD_TYPES = [
+  "NUMERIC",
+  "DECIMAL",
+  "INT",
+  "DATE",
+  "TIME",
+  "TIMESTAMP",
+  "VARCHAR",
+  "CHARACTER VARYING",
+  "BLOB",
+  "VARBINARY",
+  "LONGVARBINARY",
+  "BINARY VARYING"
+];
+var FIELD_DEFAULTS = [
+  "USER",
+  "USERNAME",
+  "CURRENT_USER",
+  "CURRENT_DATE",
+  "CURDATE",
+  "CURRENT_TIME",
+  "CURTIME",
+  "CURRENT_TIMESTAMP",
+  "CURTIMESTAMP"
+];
+function parseFieldType(typeStr) {
+  const lengthMatch = typeStr.match(/\((\d+)\)/);
+  const repMatch = typeStr.match(/\[(\d+)\]/);
+  const baseType = typeStr.replace(/\(.*?\)/, "").replace(/\[.*?\]/, "").trim();
+  return {
+    baseType,
+    length: lengthMatch ? parseInt(lengthMatch[1], 10) : void 0,
+    repetitions: repMatch ? parseInt(repMatch[1], 10) : void 0
+  };
+}
+
 // src/metadata.ts
 function parseBoolAttr(value, defaultValue) {
   if (value === void 0) return defaultValue;
@@ -1362,17 +1429,19 @@ function parseScriptEnvelope(raw, request) {
   const rawResult = envelope.scriptResult;
   let scriptResult;
   let scriptError;
-  if (rawResult !== null && typeof rawResult === "object" && "resultParameter" in rawResult) {
+  let fmsMessage;
+  if (rawResult !== null && typeof rawResult === "object" && ("code" in rawResult || "resultParameter" in rawResult)) {
     const nested = rawResult;
     scriptError = nested.code !== void 0 ? String(nested.code) : "0";
-    scriptResult = nested.resultParameter !== void 0 ? String(nested.resultParameter) : void 0;
+    scriptResult = nested.resultParameter !== void 0 ? typeof nested.resultParameter === "string" ? nested.resultParameter : JSON.stringify(nested.resultParameter) : void 0;
+    if (typeof nested.message === "string") fmsMessage = nested.message;
   } else {
     scriptError = envelope.scriptError !== void 0 ? String(envelope.scriptError) : "0";
     scriptResult = rawResult !== void 0 ? typeof rawResult === "string" ? rawResult : JSON.stringify(rawResult) : void 0;
   }
   if (scriptError !== "0") {
     throw new FMScriptError(
-      `FileMaker script error ${scriptError}`,
+      fmsMessage ? `FileMaker script error ${scriptError}: ${fmsMessage}` : `FileMaker script error ${scriptError}`,
       {
         status: 200,
         scriptError,
@@ -1759,13 +1828,13 @@ var Query = class _Query {
     return this;
   }
   // -------------------------------------------------------------------------
-  // $apply (aggregation) — requires FMS 22.0.1+ (FileMaker 2024)
+  // $apply (aggregation) — requires FMS 22.0.1+ (FileMaker 2025)
   // -------------------------------------------------------------------------
   /**
    * Set a raw `$apply` expression. Use this for advanced transformations
    * that the `aggregate()` / `groupBy()` helpers don't cover.
    *
-   * Requires FileMaker Server 2024+ (v22). Use `db.hasFeature('applyAggregation')`
+   * Requires FileMaker Server 2025+ (v22). Use `db.hasFeature('applyAggregation')`
    * to check before calling.
    *
    * @example
@@ -1781,7 +1850,7 @@ var Query = class _Query {
   /**
    * Aggregate the entity set. Produces a `$apply=aggregate(...)` expression.
    *
-   * Requires FileMaker Server 2024+ (v22).
+   * Requires FileMaker Server 2025+ (v22).
    *
    * @example
    * ```ts
@@ -1800,7 +1869,7 @@ var Query = class _Query {
    * Group the entity set by one or more fields, optionally with aggregation.
    * Produces a `$apply=groupby((fields), aggregate(...))` expression.
    *
-   * Requires FileMaker Server 2024+ (v22).
+   * Requires FileMaker Server 2025+ (v22).
    *
    * @example
    * ```ts
@@ -1951,6 +2020,295 @@ function serializeOptions(s, opts) {
   return pairs.map(([k, v]) => `${k}=${v}`).join(";");
 }
 
+// src/schema.ts
+function validateFieldDefinitions(fields) {
+  for (const f of fields) {
+    if (!f.name) throw new TypeError("SchemaEditor: field `name` is required");
+    if (!f.type) throw new TypeError("SchemaEditor: field `type` is required");
+    const { baseType } = parseFieldType(f.type);
+    const upper = baseType.toUpperCase();
+    if (!FIELD_TYPES.includes(upper)) {
+      throw new TypeError(
+        `SchemaEditor: unsupported field type "${f.type}" (base: "${baseType}"). Supported: ${FIELD_TYPES.join(", ")}`
+      );
+    }
+  }
+}
+var SchemaEditor = class {
+  constructor(client) {
+    this._client = client;
+  }
+  /**
+   * Create a new table with the given field definitions.
+   *
+   * ```ts
+   * await db.schema().createTable({
+   *   tableName: 'Company',
+   *   fields: [
+   *     { name: 'Company ID', type: 'int', primary: true },
+   *     { name: 'Company Name', type: 'varchar(100)', nullable: false },
+   *   ],
+   * })
+   * ```
+   */
+  async createTable(params, opts = {}) {
+    if (!params.tableName) throw new TypeError("SchemaEditor: `tableName` is required");
+    if (!params.fields?.length) throw new TypeError("SchemaEditor: `fields` must be a non-empty array");
+    validateFieldDefinitions(params.fields);
+    const url = `${this._client.baseUrl}/FileMaker_Tables`;
+    return executeJson(this._client._ctx, url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params),
+      accept: "json",
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+  }
+  /**
+   * Add fields to an existing table.
+   *
+   * ```ts
+   * await db.schema().addFields({
+   *   tableName: 'Company',
+   *   fields: [{ name: 'Phone', type: 'varchar(30)' }],
+   * })
+   * ```
+   */
+  async addFields(params, opts = {}) {
+    if (!params.tableName) throw new TypeError("SchemaEditor: `tableName` is required");
+    if (!params.fields?.length) throw new TypeError("SchemaEditor: `fields` must be a non-empty array");
+    validateFieldDefinitions(params.fields);
+    const url = `${this._client.baseUrl}/FileMaker_Tables/${encodePathSegment(params.tableName)}`;
+    return executeJson(this._client._ctx, url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ fields: params.fields }),
+      accept: "json",
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+  }
+  /**
+   * Delete a table and ALL its records. Irreversible.
+   *
+   * Requires `opts.confirm === true` as a safety guard.
+   *
+   * ```ts
+   * await db.schema().deleteTable('OldTable', { confirm: true })
+   * ```
+   */
+  async deleteTable(tableName, opts) {
+    if (!tableName) throw new TypeError("SchemaEditor: `tableName` is required");
+    if (opts.confirm !== true) {
+      throw new TypeError(
+        `SchemaEditor: deleteTable("${tableName}") requires { confirm: true } \u2014 this operation permanently destroys the table and all its records.`
+      );
+    }
+    const url = `${this._client.baseUrl}/FileMaker_Tables/${encodePathSegment(tableName)}`;
+    await executeJson(this._client._ctx, url, {
+      method: "DELETE",
+      accept: "json",
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+  }
+  /**
+   * Delete a field from a table. Irreversible.
+   *
+   * Requires `opts.confirm === true` as a safety guard.
+   *
+   * ```ts
+   * await db.schema().deleteField('Company', 'OldField', { confirm: true })
+   * ```
+   */
+  async deleteField(tableName, fieldName, opts) {
+    if (!tableName) throw new TypeError("SchemaEditor: `tableName` is required");
+    if (!fieldName) throw new TypeError("SchemaEditor: `fieldName` is required");
+    if (opts.confirm !== true) {
+      throw new TypeError(
+        `SchemaEditor: deleteField("${tableName}", "${fieldName}") requires { confirm: true } \u2014 this operation permanently destroys the field and all its data.`
+      );
+    }
+    const url = `${this._client.baseUrl}/FileMaker_Tables/${encodePathSegment(tableName)}/${encodePathSegment(fieldName)}`;
+    await executeJson(this._client._ctx, url, {
+      method: "DELETE",
+      accept: "json",
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+  }
+  /**
+   * Create an index on a field.
+   *
+   * ```ts
+   * await db.schema().createIndex('Company', 'Company Name')
+   * ```
+   */
+  async createIndex(tableName, fieldName, opts = {}) {
+    if (!tableName) throw new TypeError("SchemaEditor: `tableName` is required");
+    if (!fieldName) throw new TypeError("SchemaEditor: `fieldName` is required");
+    const url = `${this._client.baseUrl}/FileMaker_Indexes/${encodePathSegment(tableName)}`;
+    return executeJson(this._client._ctx, url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ indexName: fieldName }),
+      accept: "json",
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+  }
+  /**
+   * Delete an index from a field.
+   *
+   * ```ts
+   * await db.schema().deleteIndex('Company', 'Company Name')
+   * ```
+   */
+  async deleteIndex(tableName, fieldName, opts = {}) {
+    if (!tableName) throw new TypeError("SchemaEditor: `tableName` is required");
+    if (!fieldName) throw new TypeError("SchemaEditor: `fieldName` is required");
+    const url = `${this._client.baseUrl}/FileMaker_Indexes/${encodePathSegment(tableName)}/${encodePathSegment(fieldName)}`;
+    await executeJson(this._client._ctx, url, {
+      method: "DELETE",
+      accept: "json",
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+  }
+};
+
+// src/webhooks.ts
+function normalizeCreateParams(params) {
+  const out = {
+    webhook: params.webhook,
+    tableName: params.tableName
+  };
+  if (params.endpointHeaders) out.endpointHeaders = params.endpointHeaders;
+  if (params.headers && !params.endpointHeaders) out.endpointHeaders = params.headers;
+  if (params.queryHeaders) out.queryHeaders = params.queryHeaders;
+  if (params.notifySchemaChanges !== void 0) out.notifySchemaChanges = params.notifySchemaChanges;
+  if (params.select) out.select = params.select;
+  if (params.filter) out.filter = params.filter;
+  if (params.maxFailedAttempts !== void 0) out.maxFailedAttempts = params.maxFailedAttempts;
+  return out;
+}
+function extractWebhookId(data) {
+  if (!data || typeof data !== "object") return void 0;
+  const obj = data;
+  const fromResult = obj.webhookResult;
+  const id = fromResult?.webhookID ?? obj.webhookID ?? obj.id;
+  return id !== void 0 ? String(id) : void 0;
+}
+var WebhookManager = class {
+  constructor(client) {
+    this._client = client;
+  }
+  /** Build the URL for a webhook operation. */
+  _url(operation, id) {
+    const base = `${this._client.baseUrl}/Webhook.${operation}`;
+    return id !== void 0 ? `${base}(${encodePathSegment(String(id))})` : base;
+  }
+  /**
+   * Create a webhook.
+   *
+   * ```ts
+   * const { id } = await db.webhooks().create({
+   *   webhook: 'https://my.example.com:8080/webhook',
+   *   tableName: 'contact',
+   *   select: 'id,first_name',
+   *   filter: "status eq 'active'",
+   *   notifySchemaChanges: true,
+   * })
+   * ```
+   *
+   * @returns An object with the server-generated `id` of the new webhook.
+   */
+  async create(params, opts = {}) {
+    if (!params.webhook) throw new TypeError("WebhookManager: `webhook` URL is required");
+    if (!params.tableName) throw new TypeError("WebhookManager: `tableName` is required");
+    const body = JSON.stringify(normalizeCreateParams(params));
+    const data = await executeJson(this._client._ctx, this._url("Add"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      accept: "json",
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+    const id = extractWebhookId(data);
+    if (id === void 0) {
+      throw new Error("WebhookManager: Webhook.Add did not return a webhook id");
+    }
+    return { id };
+  }
+  /**
+   * Delete a webhook by its ID.
+   *
+   * ```ts
+   * await db.webhooks().remove('1')
+   * ```
+   */
+  async remove(id, opts = {}) {
+    if (id === "" || id === void 0) throw new TypeError("WebhookManager: webhook `id` is required");
+    return executeJson(this._client._ctx, this._url("Delete", id), {
+      method: "POST",
+      accept: "json",
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+  }
+  /** Alias for {@link remove} (matches the FMS endpoint name `Webhook.Delete`). */
+  async delete(id, opts = {}) {
+    return this.remove(id, opts);
+  }
+  /**
+   * Get a specific webhook's data by ID.
+   *
+   * ```ts
+   * const data = await db.webhooks().get('1')
+   * ```
+   */
+  async get(id, opts = {}) {
+    if (id === "" || id === void 0) throw new TypeError("WebhookManager: webhook `id` is required");
+    return executeJson(this._client._ctx, this._url("Get", id), {
+      method: "GET",
+      accept: "json",
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+  }
+  /**
+   * List all webhooks.
+   *
+   * ```ts
+   * const result = await db.webhooks().getAll()
+   * ```
+   */
+  async getAll(opts = {}) {
+    return executeJson(this._client._ctx, this._url("GetAll"), {
+      method: "GET",
+      accept: "json",
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+  }
+  /**
+   * Manually invoke (trigger) a webhook by ID. Useful for testing.
+   *
+   * Optionally pass `rowIDs` to target specific records; if omitted, FMS
+   * triggers the webhook for all pending records.
+   *
+   * ```ts
+   * await db.webhooks().invoke('1')
+   * await db.webhooks().invoke('1', { rowIDs: [10, 20] })
+   * ```
+   */
+  async invoke(id, opts = {}) {
+    if (id === "" || id === void 0) throw new TypeError("WebhookManager: webhook `id` is required");
+    const { rowIDs, signal, ...rest } = opts;
+    const body = JSON.stringify({ rowIDs: rowIDs ? [...rowIDs] : [] });
+    return executeJson(this._client._ctx, this._url("Invoke", id), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      accept: "json",
+      ...signal ? { signal } : {},
+      ...rest
+    });
+  }
+};
+
 // src/client.ts
 var FMSOData = class {
   constructor(options) {
@@ -2054,7 +2412,7 @@ var FMSOData = class {
    * `@fms-odata/spec-ts` `parseServerVersion`). The result is cached for the
    * lifetime of this `FMSOData` instance.
    *
-   * Returns the major version string (`'19'`, `'21'`, `'22'`, `'26'`) or
+   * Returns the major version string (`'20'`, `'21'`, `'22'`, `'26'`) or
    * `'future'` if the version is newer than the spec knows about. Returns
    * `null` if the version cannot be determined (e.g. the metadata lacks the
    * annotation).
@@ -2138,6 +2496,75 @@ var FMSOData = class {
     if (!v) return false;
     return hasFeature(v, feature);
   }
+  /**
+   * Get a `SchemaEditor` handle for DDL operations (create/delete tables,
+   * add/delete fields, create/delete indexes). Requires a FileMaker account
+   * with full access privileges.
+   *
+   * ```ts
+   * await db.schema().createTable({ tableName: 'Company', fields: [...] })
+   * ```
+   */
+  schema() {
+    if (!this._schemaEditor) this._schemaEditor = new SchemaEditor(this);
+    return this._schemaEditor;
+  }
+  /** Convenience: create a table. See {@link SchemaEditor#createTable}. */
+  async createTable(params, opts = {}) {
+    return this.schema().createTable(params, opts);
+  }
+  /** Convenience: add fields to a table. See {@link SchemaEditor#addFields}. */
+  async addFields(params, opts = {}) {
+    return this.schema().addFields(params, opts);
+  }
+  /** Convenience: delete a table (requires `confirm: true`). See {@link SchemaEditor#deleteTable}. */
+  async deleteTable(tableName, opts) {
+    return this.schema().deleteTable(tableName, opts);
+  }
+  /** Convenience: delete a field (requires `confirm: true`). See {@link SchemaEditor#deleteField}. */
+  async deleteField(tableName, fieldName, opts) {
+    return this.schema().deleteField(tableName, fieldName, opts);
+  }
+  /** Convenience: create an index. See {@link SchemaEditor#createIndex}. */
+  async createIndex(tableName, fieldName, opts = {}) {
+    return this.schema().createIndex(tableName, fieldName, opts);
+  }
+  /** Convenience: delete an index. See {@link SchemaEditor#deleteIndex}. */
+  async deleteIndex(tableName, fieldName, opts = {}) {
+    return this.schema().deleteIndex(tableName, fieldName, opts);
+  }
+  /**
+   * Get a `WebhookManager` handle for webhook CRUD operations (create, remove,
+   * get, getAll, invoke). Requires FileMaker Server 2025+ (v22).
+   *
+   * ```ts
+   * await db.webhooks().create({ webhook: 'https://...', tableName: 'contact' })
+   * ```
+   */
+  webhooks() {
+    if (!this._webhookManager) this._webhookManager = new WebhookManager(this);
+    return this._webhookManager;
+  }
+  /** Convenience: create a webhook. See {@link WebhookManager#create}. */
+  async createWebhook(params, opts = {}) {
+    return this.webhooks().create(params, opts);
+  }
+  /** Convenience: delete a webhook by ID. See {@link WebhookManager#remove}. */
+  async removeWebhook(id, opts = {}) {
+    return this.webhooks().remove(id, opts);
+  }
+  /** Convenience: get a webhook by ID. See {@link WebhookManager#get}. */
+  async getWebhook(id, opts = {}) {
+    return this.webhooks().get(id, opts);
+  }
+  /** Convenience: list all webhooks. See {@link WebhookManager#getAll}. */
+  async getAllWebhooks(opts = {}) {
+    return this.webhooks().getAll(opts);
+  }
+  /** Convenience: manually invoke a webhook by ID. See {@link WebhookManager#invoke}. */
+  async invokeWebhook(id, opts = {}) {
+    return this.webhooks().invoke(id, opts);
+  }
   /**
    * Create a new `$batch` builder for composing multiple OData operations
    * into a single HTTP round-trip.
@@ -2171,6 +2598,8 @@ export {
   Changeset,
   ContainerRef,
   EntityRef,
+  FIELD_DEFAULTS,
+  FIELD_TYPES,
   FMSOData as FMOData,
   FMSODataError as FMODataError,
   FMSOData,
@@ -2183,17 +2612,20 @@ export {
   MetadataFetcher,
   ODATA_PROTOCOL_VERSION,
   Query,
+  SchemaEditor,
   ScriptInvoker,
+  WebhookManager,
   basicAuth,
+  bearerAuth,
   buildContainerJsonBody,
   filterFactory,
-  fmidAuth,
   hasFeature,
   hasQueryOption,
   isFMSODataError as isFMODataError,
   isFMSODataError,
   isFMScriptError,
   minVersionForFeature,
+  parseFieldType,
   parseServerVersion,
   parseVersionString,
   sniffContainerMime,