@malloy-publisher/sdk 0.0.116 → 0.0.118

package/dist/ServerProvider-v0TajMUn.es.js

@@ -0,0 +1,2341 @@
+import { jsx as w } from "react/jsx-runtime";
+import { QueryClient as M, QueryClientProvider as E } from "@tanstack/react-query";
+import u from "axios";
+import { useContext as L, createContext as H, useMemo as W } from "react";
+const f = new M({
+  defaultOptions: {
+    queries: {
+      retry: !1,
+      throwOnError: !1
+    },
+    mutations: {
+      retry: !1,
+      throwOnError: !1
+    }
+  }
+}), m = "http://localhost/api/v0".replace(/\/+$/, "");
+class j {
+  constructor(a, e = m, r = u) {
+    this.basePath = e, this.axios = r, a && (this.configuration = a, this.basePath = a.basePath ?? e);
+  }
+  configuration;
+}
+class D extends Error {
+  constructor(a, e) {
+    super(e), this.field = a, this.name = "RequiredError";
+  }
+}
+const P = {}, V = "https://example.com", d = function(c, a, e) {
+  if (e == null)
+    throw new D(a, `Required parameter ${a} was null or undefined when calling ${c}.`);
+};
+function N(c, a, e = "") {
+  a != null && (typeof a == "object" ? Array.isArray(a) ? a.forEach((r) => N(c, r, e)) : Object.keys(a).forEach(
+    (r) => N(c, a[r], `${e}${e !== "" ? "." : ""}${r}`)
+  ) : c.has(e) ? c.append(e, a) : c.set(e, a));
+}
+const O = function(c, ...a) {
+  const e = new URLSearchParams(c.search);
+  N(e, a), c.search = e.toString();
+}, A = function(c, a, e) {
+  const r = typeof c != "string";
+  return (r && e && e.isJsonMime ? e.isJsonMime(a.headers["Content-Type"]) : r) ? JSON.stringify(c !== void 0 ? c : {}) : c || "";
+}, b = function(c) {
+  return c.pathname + c.search + c.hash;
+}, g = function(c, a, e, r) {
+  return (t = a, s = e) => {
+    const o = { ...c.options, url: (t.defaults.baseURL ? "" : r?.basePath ?? s) + c.url };
+    return t.request(o);
+  };
+}, Oe = {
+  Postgres: "postgres",
+  Bigquery: "bigquery",
+  Snowflake: "snowflake",
+  Trino: "trino",
+  Mysql: "mysql"
+}, be = {
+  Ok: "ok",
+  Failed: "failed"
+}, ge = {
+  Embedded: "embedded",
+  Materialized: "materialized"
+}, ye = {
+  Markdown: "markdown",
+  Code: "code"
+}, G = function(c) {
+  return {
+    /**
+     * Retrieves detailed information about a specific database connection within a project. This includes connection configuration, credentials (if accessible), and metadata. Useful for inspecting connection settings and troubleshooting connectivity issues. 
+     * @summary Get connection details
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getConnection: async (a, e, r = {}) => {
+      d("getConnection", "projectName", a), d("getConnection", "connectionName", e);
+      const t = "/projects/{projectName}/connections/{connectionName}".replace("{projectName}", encodeURIComponent(String(a))).replace("{connectionName}", encodeURIComponent(String(e))), s = new URL(t, V);
+      let o;
+      c && (o = c.baseOptions);
+      const n = { method: "GET", ...o, ...r }, l = {};
+      O(s, {});
+      let p = o && o.headers ? o.headers : {};
+      return n.headers = { ...l, ...p, ...r.headers }, {
+        url: b(s),
+        options: n
+      };
+    },
+    /**
+     * **DEPRECATED**: This endpoint is deprecated and may be removed in future versions. Use the POST version instead for better security and functionality.  Executes a SQL statement against the specified database connection and returns the results. The query results include data, metadata, and execution information. 
+     * @summary Execute SQL query (deprecated)
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} [sqlStatement] SQL statement
+     * @param {string} [_options] Options
+     * @param {*} [options] Override http request option.
+     * @deprecated
+     * @throws {RequiredError}
+     */
+    getQuerydata: async (a, e, r, t, s = {}) => {
+      d("getQuerydata", "projectName", a), d("getQuerydata", "connectionName", e);
+      const o = "/projects/{projectName}/connections/{connectionName}/queryData".replace("{projectName}", encodeURIComponent(String(a))).replace("{connectionName}", encodeURIComponent(String(e))), n = new URL(o, V);
+      let l;
+      c && (l = c.baseOptions);
+      const i = { method: "GET", ...l, ...s }, p = {}, h = {};
+      r !== void 0 && (h.sqlStatement = r), t !== void 0 && (h.options = t), O(n, h);
+      let y = l && l.headers ? l.headers : {};
+      return i.headers = { ...p, ...y, ...s.headers }, {
+        url: b(n),
+        options: i
+      };
+    },
+    /**
+     * **DEPRECATED**: This endpoint is deprecated and may be removed in future versions. Use the POST version instead for better security and functionality.  Creates a Malloy source from a SQL statement using the specified connection. The SQL statement is executed to generate a source definition that can be used in Malloy models. 
+     * @summary Get SQL source (deprecated)
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} [sqlStatement] SQL statement
+     * @param {*} [options] Override http request option.
+     * @deprecated
+     * @throws {RequiredError}
+     */
+    getSqlsource: async (a, e, r, t = {}) => {
+      d("getSqlsource", "projectName", a), d("getSqlsource", "connectionName", e);
+      const s = "/projects/{projectName}/connections/{connectionName}/sqlSource".replace("{projectName}", encodeURIComponent(String(a))).replace("{connectionName}", encodeURIComponent(String(e))), o = new URL(s, V);
+      let n;
+      c && (n = c.baseOptions);
+      const l = { method: "GET", ...n, ...t }, i = {}, p = {};
+      r !== void 0 && (p.sqlStatement = r), O(o, p);
+      let h = n && n.headers ? n.headers : {};
+      return l.headers = { ...i, ...h, ...t.headers }, {
+        url: b(o),
+        options: l
+      };
+    },
+    /**
+     * Retrieves information about a specific table or view from the database connection. This includes table schema, column definitions, and metadata. The table can be specified by either tableKey or tablePath parameters, depending on the database type. 
+     * @summary Get table source information
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} [tableKey] Table key
+     * @param {string} [tablePath] Table path
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getTablesource: async (a, e, r, t, s = {}) => {
+      d("getTablesource", "projectName", a), d("getTablesource", "connectionName", e);
+      const o = "/projects/{projectName}/connections/{connectionName}/tableSource".replace("{projectName}", encodeURIComponent(String(a))).replace("{connectionName}", encodeURIComponent(String(e))), n = new URL(o, V);
+      let l;
+      c && (l = c.baseOptions);
+      const i = { method: "GET", ...l, ...s }, p = {}, h = {};
+      r !== void 0 && (h.tableKey = r), t !== void 0 && (h.tablePath = t), O(n, h);
+      let y = l && l.headers ? l.headers : {};
+      return i.headers = { ...p, ...y, ...s.headers }, {
+        url: b(n),
+        options: i
+      };
+    },
+    /**
+     * **DEPRECATED**: This endpoint is deprecated and may be removed in future versions. Use the POST version instead for better security and functionality.  Creates a temporary table from a SQL statement using the specified connection. Temporary tables are useful for storing intermediate results during complex queries. 
+     * @summary Create temporary table (deprecated)
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} [sqlStatement] SQL statement
+     * @param {*} [options] Override http request option.
+     * @deprecated
+     * @throws {RequiredError}
+     */
+    getTemporarytable: async (a, e, r, t = {}) => {
+      d("getTemporarytable", "projectName", a), d("getTemporarytable", "connectionName", e);
+      const s = "/projects/{projectName}/connections/{connectionName}/temporaryTable".replace("{projectName}", encodeURIComponent(String(a))).replace("{connectionName}", encodeURIComponent(String(e))), o = new URL(s, V);
+      let n;
+      c && (n = c.baseOptions);
+      const l = { method: "GET", ...n, ...t }, i = {}, p = {};
+      r !== void 0 && (p.sqlStatement = r), O(o, p);
+      let h = n && n.headers ? n.headers : {};
+      return l.headers = { ...i, ...h, ...t.headers }, {
+        url: b(o),
+        options: l
+      };
+    },
+    /**
+     * Retrieves a list of all database connections configured for the specified project. Each connection includes its configuration, type, and status information. This endpoint is useful for discovering available data sources within a project. 
+     * @summary List project database connections
+     * @param {string} projectName Name of the project
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listConnections: async (a, e = {}) => {
+      d("listConnections", "projectName", a);
+      const r = "/projects/{projectName}/connections".replace("{projectName}", encodeURIComponent(String(a))), t = new URL(r, V);
+      let s;
+      c && (s = c.baseOptions);
+      const o = { method: "GET", ...s, ...e }, n = {};
+      O(t, {});
+      let i = s && s.headers ? s.headers : {};
+      return o.headers = { ...n, ...i, ...e.headers }, {
+        url: b(t),
+        options: o
+      };
+    },
+    /**
+     * Retrieves a list of all schemas (databases) available in the specified connection. Each schema includes metadata such as name, description, and whether it\'s the default schema. This endpoint is useful for exploring the database structure and discovering available data sources. 
+     * @summary List database schemas
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listSchemas: async (a, e, r = {}) => {
+      d("listSchemas", "projectName", a), d("listSchemas", "connectionName", e);
+      const t = "/projects/{projectName}/connections/{connectionName}/schemas".replace("{projectName}", encodeURIComponent(String(a))).replace("{connectionName}", encodeURIComponent(String(e))), s = new URL(t, V);
+      let o;
+      c && (o = c.baseOptions);
+      const n = { method: "GET", ...o, ...r }, l = {};
+      O(s, {});
+      let p = o && o.headers ? o.headers : {};
+      return n.headers = { ...l, ...p, ...r.headers }, {
+        url: b(s),
+        options: n
+      };
+    },
+    /**
+     * Retrieves a list of all tables and views available in the specified database schema. This endpoint is useful for discovering available data sources and exploring the database structure. The schema must exist in the connection for this operation to succeed. 
+     * @summary List tables in database schema
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} schemaName Name of the schema
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listTables: async (a, e, r, t = {}) => {
+      d("listTables", "projectName", a), d("listTables", "connectionName", e), d("listTables", "schemaName", r);
+      const s = "/projects/{projectName}/connections/{connectionName}/schemas/{schemaName}/tables".replace("{projectName}", encodeURIComponent(String(a))).replace("{connectionName}", encodeURIComponent(String(e))).replace("{schemaName}", encodeURIComponent(String(r))), o = new URL(s, V);
+      let n;
+      c && (n = c.baseOptions);
+      const l = { method: "GET", ...n, ...t }, i = {};
+      O(o, {});
+      let h = n && n.headers ? n.headers : {};
+      return l.headers = { ...i, ...h, ...t.headers }, {
+        url: b(o),
+        options: l
+      };
+    },
+    /**
+     * Executes a SQL statement against the specified database connection and returns the results. This is the preferred method over the deprecated GET version as it provides better security and supports larger SQL statements. The results include data, metadata, and execution information. 
+     * @summary Execute SQL query
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {PostSqlsourceRequest} postSqlsourceRequest SQL statement to execute
+     * @param {string} [_options] Options
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postQuerydata: async (a, e, r, t, s = {}) => {
+      d("postQuerydata", "projectName", a), d("postQuerydata", "connectionName", e), d("postQuerydata", "postSqlsourceRequest", r);
+      const o = "/projects/{projectName}/connections/{connectionName}/queryData".replace("{projectName}", encodeURIComponent(String(a))).replace("{connectionName}", encodeURIComponent(String(e))), n = new URL(o, V);
+      let l;
+      c && (l = c.baseOptions);
+      const i = { method: "POST", ...l, ...s }, p = {}, h = {};
+      t !== void 0 && (h.options = t), p["Content-Type"] = "application/json", O(n, h);
+      let y = l && l.headers ? l.headers : {};
+      return i.headers = { ...p, ...y, ...s.headers }, i.data = A(r, i, c), {
+        url: b(n),
+        options: i
+      };
+    },
+    /**
+     * Creates a Malloy source from a SQL statement using the specified database connection. The SQL statement is executed to generate a source definition that can be used in Malloy models. This is the preferred method over the deprecated GET version as it provides better security and supports larger SQL statements. 
+     * @summary Create SQL source from statement
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {PostSqlsourceRequest} postSqlsourceRequest SQL statement to fetch the SQL source
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postSqlsource: async (a, e, r, t = {}) => {
+      d("postSqlsource", "projectName", a), d("postSqlsource", "connectionName", e), d("postSqlsource", "postSqlsourceRequest", r);
+      const s = "/projects/{projectName}/connections/{connectionName}/sqlSource".replace("{projectName}", encodeURIComponent(String(a))).replace("{connectionName}", encodeURIComponent(String(e))), o = new URL(s, V);
+      let n;
+      c && (n = c.baseOptions);
+      const l = { method: "POST", ...n, ...t }, i = {}, p = {};
+      i["Content-Type"] = "application/json", O(o, p);
+      let h = n && n.headers ? n.headers : {};
+      return l.headers = { ...i, ...h, ...t.headers }, l.data = A(r, l, c), {
+        url: b(o),
+        options: l
+      };
+    },
+    /**
+     * Creates a temporary table from a SQL statement using the specified database connection. This is the preferred method over the deprecated GET version as it provides better security and supports larger SQL statements. Temporary tables are useful for storing intermediate results during complex queries and data processing workflows. 
+     * @summary Create temporary table
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {PostSqlsourceRequest} postSqlsourceRequest SQL statement to create the temporary table
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postTemporarytable: async (a, e, r, t = {}) => {
+      d("postTemporarytable", "projectName", a), d("postTemporarytable", "connectionName", e), d("postTemporarytable", "postSqlsourceRequest", r);
+      const s = "/projects/{projectName}/connections/{connectionName}/temporaryTable".replace("{projectName}", encodeURIComponent(String(a))).replace("{connectionName}", encodeURIComponent(String(e))), o = new URL(s, V);
+      let n;
+      c && (n = c.baseOptions);
+      const l = { method: "POST", ...n, ...t }, i = {}, p = {};
+      i["Content-Type"] = "application/json", O(o, p);
+      let h = n && n.headers ? n.headers : {};
+      return l.headers = { ...i, ...h, ...t.headers }, l.data = A(r, l, c), {
+        url: b(o),
+        options: l
+      };
+    },
+    /**
+     * Tests the connectivity and configuration of an existing database connection within a project. This endpoint validates that the connection can be established, credentials are valid, and the database is accessible. Useful for monitoring connection health and troubleshooting. 
+     * @summary Test existing project connection
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    testConnection: async (a, e, r = {}) => {
+      d("testConnection", "projectName", a), d("testConnection", "connectionName", e);
+      const t = "/projects/{projectName}/connections/{connectionName}/test".replace("{projectName}", encodeURIComponent(String(a))).replace("{connectionName}", encodeURIComponent(String(e))), s = new URL(t, V);
+      let o;
+      c && (o = c.baseOptions);
+      const n = { method: "GET", ...o, ...r }, l = {};
+      O(s, {});
+      let p = o && o.headers ? o.headers : {};
+      return n.headers = { ...l, ...p, ...r.headers }, {
+        url: b(s),
+        options: n
+      };
+    },
+    /**
+     * Validates a database connection configuration without adding it to any project. This endpoint allows you to test connection parameters, credentials, and network connectivity before committing the connection to a project. Useful for troubleshooting connection issues and validating configurations during setup. 
+     * @summary Test database connection configuration
+     * @param {Connection} connection 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    testConnectionConfiguration: async (a, e = {}) => {
+      d("testConnectionConfiguration", "connection", a);
+      const r = "/connections/test", t = new URL(r, V);
+      let s;
+      c && (s = c.baseOptions);
+      const o = { method: "POST", ...s, ...e }, n = {}, l = {};
+      n["Content-Type"] = "application/json", O(t, l);
+      let i = s && s.headers ? s.headers : {};
+      return o.headers = { ...n, ...i, ...e.headers }, o.data = A(a, o, c), {
+        url: b(t),
+        options: o
+      };
+    }
+  };
+}, S = function(c) {
+  const a = G(c);
+  return {
+    /**
+     * Retrieves detailed information about a specific database connection within a project. This includes connection configuration, credentials (if accessible), and metadata. Useful for inspecting connection settings and troubleshooting connectivity issues. 
+     * @summary Get connection details
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async getConnection(e, r, t) {
+      const s = await a.getConnection(e, r, t), o = c?.serverIndex ?? 0, n = P["ConnectionsApi.getConnection"]?.[o]?.url;
+      return (l, i) => g(s, u, m, c)(l, n || i);
+    },
+    /**
+     * **DEPRECATED**: This endpoint is deprecated and may be removed in future versions. Use the POST version instead for better security and functionality.  Executes a SQL statement against the specified database connection and returns the results. The query results include data, metadata, and execution information. 
+     * @summary Execute SQL query (deprecated)
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} [sqlStatement] SQL statement
+     * @param {string} [_options] Options
+     * @param {*} [options] Override http request option.
+     * @deprecated
+     * @throws {RequiredError}
+     */
+    async getQuerydata(e, r, t, s, o) {
+      const n = await a.getQuerydata(e, r, t, s, o), l = c?.serverIndex ?? 0, i = P["ConnectionsApi.getQuerydata"]?.[l]?.url;
+      return (p, h) => g(n, u, m, c)(p, i || h);
+    },
+    /**
+     * **DEPRECATED**: This endpoint is deprecated and may be removed in future versions. Use the POST version instead for better security and functionality.  Creates a Malloy source from a SQL statement using the specified connection. The SQL statement is executed to generate a source definition that can be used in Malloy models. 
+     * @summary Get SQL source (deprecated)
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} [sqlStatement] SQL statement
+     * @param {*} [options] Override http request option.
+     * @deprecated
+     * @throws {RequiredError}
+     */
+    async getSqlsource(e, r, t, s) {
+      const o = await a.getSqlsource(e, r, t, s), n = c?.serverIndex ?? 0, l = P["ConnectionsApi.getSqlsource"]?.[n]?.url;
+      return (i, p) => g(o, u, m, c)(i, l || p);
+    },
+    /**
+     * Retrieves information about a specific table or view from the database connection. This includes table schema, column definitions, and metadata. The table can be specified by either tableKey or tablePath parameters, depending on the database type. 
+     * @summary Get table source information
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} [tableKey] Table key
+     * @param {string} [tablePath] Table path
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async getTablesource(e, r, t, s, o) {
+      const n = await a.getTablesource(e, r, t, s, o), l = c?.serverIndex ?? 0, i = P["ConnectionsApi.getTablesource"]?.[l]?.url;
+      return (p, h) => g(n, u, m, c)(p, i || h);
+    },
+    /**
+     * **DEPRECATED**: This endpoint is deprecated and may be removed in future versions. Use the POST version instead for better security and functionality.  Creates a temporary table from a SQL statement using the specified connection. Temporary tables are useful for storing intermediate results during complex queries. 
+     * @summary Create temporary table (deprecated)
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} [sqlStatement] SQL statement
+     * @param {*} [options] Override http request option.
+     * @deprecated
+     * @throws {RequiredError}
+     */
+    async getTemporarytable(e, r, t, s) {
+      const o = await a.getTemporarytable(e, r, t, s), n = c?.serverIndex ?? 0, l = P["ConnectionsApi.getTemporarytable"]?.[n]?.url;
+      return (i, p) => g(o, u, m, c)(i, l || p);
+    },
+    /**
+     * Retrieves a list of all database connections configured for the specified project. Each connection includes its configuration, type, and status information. This endpoint is useful for discovering available data sources within a project. 
+     * @summary List project database connections
+     * @param {string} projectName Name of the project
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async listConnections(e, r) {
+      const t = await a.listConnections(e, r), s = c?.serverIndex ?? 0, o = P["ConnectionsApi.listConnections"]?.[s]?.url;
+      return (n, l) => g(t, u, m, c)(n, o || l);
+    },
+    /**
+     * Retrieves a list of all schemas (databases) available in the specified connection. Each schema includes metadata such as name, description, and whether it\'s the default schema. This endpoint is useful for exploring the database structure and discovering available data sources. 
+     * @summary List database schemas
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async listSchemas(e, r, t) {
+      const s = await a.listSchemas(e, r, t), o = c?.serverIndex ?? 0, n = P["ConnectionsApi.listSchemas"]?.[o]?.url;
+      return (l, i) => g(s, u, m, c)(l, n || i);
+    },
+    /**
+     * Retrieves a list of all tables and views available in the specified database schema. This endpoint is useful for discovering available data sources and exploring the database structure. The schema must exist in the connection for this operation to succeed. 
+     * @summary List tables in database schema
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} schemaName Name of the schema
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async listTables(e, r, t, s) {
+      const o = await a.listTables(e, r, t, s), n = c?.serverIndex ?? 0, l = P["ConnectionsApi.listTables"]?.[n]?.url;
+      return (i, p) => g(o, u, m, c)(i, l || p);
+    },
+    /**
+     * Executes a SQL statement against the specified database connection and returns the results. This is the preferred method over the deprecated GET version as it provides better security and supports larger SQL statements. The results include data, metadata, and execution information. 
+     * @summary Execute SQL query
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {PostSqlsourceRequest} postSqlsourceRequest SQL statement to execute
+     * @param {string} [_options] Options
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async postQuerydata(e, r, t, s, o) {
+      const n = await a.postQuerydata(e, r, t, s, o), l = c?.serverIndex ?? 0, i = P["ConnectionsApi.postQuerydata"]?.[l]?.url;
+      return (p, h) => g(n, u, m, c)(p, i || h);
+    },
+    /**
+     * Creates a Malloy source from a SQL statement using the specified database connection. The SQL statement is executed to generate a source definition that can be used in Malloy models. This is the preferred method over the deprecated GET version as it provides better security and supports larger SQL statements. 
+     * @summary Create SQL source from statement
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {PostSqlsourceRequest} postSqlsourceRequest SQL statement to fetch the SQL source
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async postSqlsource(e, r, t, s) {
+      const o = await a.postSqlsource(e, r, t, s), n = c?.serverIndex ?? 0, l = P["ConnectionsApi.postSqlsource"]?.[n]?.url;
+      return (i, p) => g(o, u, m, c)(i, l || p);
+    },
+    /**
+     * Creates a temporary table from a SQL statement using the specified database connection. This is the preferred method over the deprecated GET version as it provides better security and supports larger SQL statements. Temporary tables are useful for storing intermediate results during complex queries and data processing workflows. 
+     * @summary Create temporary table
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {PostSqlsourceRequest} postSqlsourceRequest SQL statement to create the temporary table
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async postTemporarytable(e, r, t, s) {
+      const o = await a.postTemporarytable(e, r, t, s), n = c?.serverIndex ?? 0, l = P["ConnectionsApi.postTemporarytable"]?.[n]?.url;
+      return (i, p) => g(o, u, m, c)(i, l || p);
+    },
+    /**
+     * Tests the connectivity and configuration of an existing database connection within a project. This endpoint validates that the connection can be established, credentials are valid, and the database is accessible. Useful for monitoring connection health and troubleshooting. 
+     * @summary Test existing project connection
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async testConnection(e, r, t) {
+      const s = await a.testConnection(e, r, t), o = c?.serverIndex ?? 0, n = P["ConnectionsApi.testConnection"]?.[o]?.url;
+      return (l, i) => g(s, u, m, c)(l, n || i);
+    },
+    /**
+     * Validates a database connection configuration without adding it to any project. This endpoint allows you to test connection parameters, credentials, and network connectivity before committing the connection to a project. Useful for troubleshooting connection issues and validating configurations during setup. 
+     * @summary Test database connection configuration
+     * @param {Connection} connection 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async testConnectionConfiguration(e, r) {
+      const t = await a.testConnectionConfiguration(e, r), s = c?.serverIndex ?? 0, o = P["ConnectionsApi.testConnectionConfiguration"]?.[s]?.url;
+      return (n, l) => g(t, u, m, c)(n, o || l);
+    }
+  };
+}, Se = function(c, a, e) {
+  const r = S(c);
+  return {
+    /**
+     * Retrieves detailed information about a specific database connection within a project. This includes connection configuration, credentials (if accessible), and metadata. Useful for inspecting connection settings and troubleshooting connectivity issues. 
+     * @summary Get connection details
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getConnection(t, s, o) {
+      return r.getConnection(t, s, o).then((n) => n(e, a));
+    },
+    /**
+     * **DEPRECATED**: This endpoint is deprecated and may be removed in future versions. Use the POST version instead for better security and functionality.  Executes a SQL statement against the specified database connection and returns the results. The query results include data, metadata, and execution information. 
+     * @summary Execute SQL query (deprecated)
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} [sqlStatement] SQL statement
+     * @param {string} [_options] Options
+     * @param {*} [options] Override http request option.
+     * @deprecated
+     * @throws {RequiredError}
+     */
+    getQuerydata(t, s, o, n, l) {
+      return r.getQuerydata(t, s, o, n, l).then((i) => i(e, a));
+    },
+    /**
+     * **DEPRECATED**: This endpoint is deprecated and may be removed in future versions. Use the POST version instead for better security and functionality.  Creates a Malloy source from a SQL statement using the specified connection. The SQL statement is executed to generate a source definition that can be used in Malloy models. 
+     * @summary Get SQL source (deprecated)
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} [sqlStatement] SQL statement
+     * @param {*} [options] Override http request option.
+     * @deprecated
+     * @throws {RequiredError}
+     */
+    getSqlsource(t, s, o, n) {
+      return r.getSqlsource(t, s, o, n).then((l) => l(e, a));
+    },
+    /**
+     * Retrieves information about a specific table or view from the database connection. This includes table schema, column definitions, and metadata. The table can be specified by either tableKey or tablePath parameters, depending on the database type. 
+     * @summary Get table source information
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} [tableKey] Table key
+     * @param {string} [tablePath] Table path
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getTablesource(t, s, o, n, l) {
+      return r.getTablesource(t, s, o, n, l).then((i) => i(e, a));
+    },
+    /**
+     * **DEPRECATED**: This endpoint is deprecated and may be removed in future versions. Use the POST version instead for better security and functionality.  Creates a temporary table from a SQL statement using the specified connection. Temporary tables are useful for storing intermediate results during complex queries. 
+     * @summary Create temporary table (deprecated)
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} [sqlStatement] SQL statement
+     * @param {*} [options] Override http request option.
+     * @deprecated
+     * @throws {RequiredError}
+     */
+    getTemporarytable(t, s, o, n) {
+      return r.getTemporarytable(t, s, o, n).then((l) => l(e, a));
+    },
+    /**
+     * Retrieves a list of all database connections configured for the specified project. Each connection includes its configuration, type, and status information. This endpoint is useful for discovering available data sources within a project. 
+     * @summary List project database connections
+     * @param {string} projectName Name of the project
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listConnections(t, s) {
+      return r.listConnections(t, s).then((o) => o(e, a));
+    },
+    /**
+     * Retrieves a list of all schemas (databases) available in the specified connection. Each schema includes metadata such as name, description, and whether it\'s the default schema. This endpoint is useful for exploring the database structure and discovering available data sources. 
+     * @summary List database schemas
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listSchemas(t, s, o) {
+      return r.listSchemas(t, s, o).then((n) => n(e, a));
+    },
+    /**
+     * Retrieves a list of all tables and views available in the specified database schema. This endpoint is useful for discovering available data sources and exploring the database structure. The schema must exist in the connection for this operation to succeed. 
+     * @summary List tables in database schema
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {string} schemaName Name of the schema
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listTables(t, s, o, n) {
+      return r.listTables(t, s, o, n).then((l) => l(e, a));
+    },
+    /**
+     * Executes a SQL statement against the specified database connection and returns the results. This is the preferred method over the deprecated GET version as it provides better security and supports larger SQL statements. The results include data, metadata, and execution information. 
+     * @summary Execute SQL query
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {PostSqlsourceRequest} postSqlsourceRequest SQL statement to execute
+     * @param {string} [_options] Options
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postQuerydata(t, s, o, n, l) {
+      return r.postQuerydata(t, s, o, n, l).then((i) => i(e, a));
+    },
+    /**
+     * Creates a Malloy source from a SQL statement using the specified database connection. The SQL statement is executed to generate a source definition that can be used in Malloy models. This is the preferred method over the deprecated GET version as it provides better security and supports larger SQL statements. 
+     * @summary Create SQL source from statement
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {PostSqlsourceRequest} postSqlsourceRequest SQL statement to fetch the SQL source
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postSqlsource(t, s, o, n) {
+      return r.postSqlsource(t, s, o, n).then((l) => l(e, a));
+    },
+    /**
+     * Creates a temporary table from a SQL statement using the specified database connection. This is the preferred method over the deprecated GET version as it provides better security and supports larger SQL statements. Temporary tables are useful for storing intermediate results during complex queries and data processing workflows. 
+     * @summary Create temporary table
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {PostSqlsourceRequest} postSqlsourceRequest SQL statement to create the temporary table
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postTemporarytable(t, s, o, n) {
+      return r.postTemporarytable(t, s, o, n).then((l) => l(e, a));
+    },
+    /**
+     * Tests the connectivity and configuration of an existing database connection within a project. This endpoint validates that the connection can be established, credentials are valid, and the database is accessible. Useful for monitoring connection health and troubleshooting. 
+     * @summary Test existing project connection
+     * @param {string} projectName Name of the project
+     * @param {string} connectionName Name of the connection
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    testConnection(t, s, o) {
+      return r.testConnection(t, s, o).then((n) => n(e, a));
+    },
+    /**
+     * Validates a database connection configuration without adding it to any project. This endpoint allows you to test connection parameters, credentials, and network connectivity before committing the connection to a project. Useful for troubleshooting connection issues and validating configurations during setup. 
+     * @summary Test database connection configuration
+     * @param {Connection} connection 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    testConnectionConfiguration(t, s) {
+      return r.testConnectionConfiguration(t, s).then((o) => o(e, a));
+    }
+  };
+};
+class z extends j {
+  /**
+   * Retrieves detailed information about a specific database connection within a project. This includes connection configuration, credentials (if accessible), and metadata. Useful for inspecting connection settings and troubleshooting connectivity issues. 
+   * @summary Get connection details
+   * @param {string} projectName Name of the project
+   * @param {string} connectionName Name of the connection
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  getConnection(a, e, r) {
+    return S(this.configuration).getConnection(a, e, r).then((t) => t(this.axios, this.basePath));
+  }
+  /**
+   * **DEPRECATED**: This endpoint is deprecated and may be removed in future versions. Use the POST version instead for better security and functionality.  Executes a SQL statement against the specified database connection and returns the results. The query results include data, metadata, and execution information. 
+   * @summary Execute SQL query (deprecated)
+   * @param {string} projectName Name of the project
+   * @param {string} connectionName Name of the connection
+   * @param {string} [sqlStatement] SQL statement
+   * @param {string} [_options] Options
+   * @param {*} [options] Override http request option.
+   * @deprecated
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  getQuerydata(a, e, r, t, s) {
+    return S(this.configuration).getQuerydata(a, e, r, t, s).then((o) => o(this.axios, this.basePath));
+  }
+  /**
+   * **DEPRECATED**: This endpoint is deprecated and may be removed in future versions. Use the POST version instead for better security and functionality.  Creates a Malloy source from a SQL statement using the specified connection. The SQL statement is executed to generate a source definition that can be used in Malloy models. 
+   * @summary Get SQL source (deprecated)
+   * @param {string} projectName Name of the project
+   * @param {string} connectionName Name of the connection
+   * @param {string} [sqlStatement] SQL statement
+   * @param {*} [options] Override http request option.
+   * @deprecated
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  getSqlsource(a, e, r, t) {
+    return S(this.configuration).getSqlsource(a, e, r, t).then((s) => s(this.axios, this.basePath));
+  }
+  /**
+   * Retrieves information about a specific table or view from the database connection. This includes table schema, column definitions, and metadata. The table can be specified by either tableKey or tablePath parameters, depending on the database type. 
+   * @summary Get table source information
+   * @param {string} projectName Name of the project
+   * @param {string} connectionName Name of the connection
+   * @param {string} [tableKey] Table key
+   * @param {string} [tablePath] Table path
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  getTablesource(a, e, r, t, s) {
+    return S(this.configuration).getTablesource(a, e, r, t, s).then((o) => o(this.axios, this.basePath));
+  }
+  /**
+   * **DEPRECATED**: This endpoint is deprecated and may be removed in future versions. Use the POST version instead for better security and functionality.  Creates a temporary table from a SQL statement using the specified connection. Temporary tables are useful for storing intermediate results during complex queries. 
+   * @summary Create temporary table (deprecated)
+   * @param {string} projectName Name of the project
+   * @param {string} connectionName Name of the connection
+   * @param {string} [sqlStatement] SQL statement
+   * @param {*} [options] Override http request option.
+   * @deprecated
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  getTemporarytable(a, e, r, t) {
+    return S(this.configuration).getTemporarytable(a, e, r, t).then((s) => s(this.axios, this.basePath));
+  }
+  /**
+   * Retrieves a list of all database connections configured for the specified project. Each connection includes its configuration, type, and status information. This endpoint is useful for discovering available data sources within a project. 
+   * @summary List project database connections
+   * @param {string} projectName Name of the project
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  listConnections(a, e) {
+    return S(this.configuration).listConnections(a, e).then((r) => r(this.axios, this.basePath));
+  }
+  /**
+   * Retrieves a list of all schemas (databases) available in the specified connection. Each schema includes metadata such as name, description, and whether it\'s the default schema. This endpoint is useful for exploring the database structure and discovering available data sources. 
+   * @summary List database schemas
+   * @param {string} projectName Name of the project
+   * @param {string} connectionName Name of the connection
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  listSchemas(a, e, r) {
+    return S(this.configuration).listSchemas(a, e, r).then((t) => t(this.axios, this.basePath));
+  }
+  /**
+   * Retrieves a list of all tables and views available in the specified database schema. This endpoint is useful for discovering available data sources and exploring the database structure. The schema must exist in the connection for this operation to succeed. 
+   * @summary List tables in database schema
+   * @param {string} projectName Name of the project
+   * @param {string} connectionName Name of the connection
+   * @param {string} schemaName Name of the schema
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  listTables(a, e, r, t) {
+    return S(this.configuration).listTables(a, e, r, t).then((s) => s(this.axios, this.basePath));
+  }
+  /**
+   * Executes a SQL statement against the specified database connection and returns the results. This is the preferred method over the deprecated GET version as it provides better security and supports larger SQL statements. The results include data, metadata, and execution information. 
+   * @summary Execute SQL query
+   * @param {string} projectName Name of the project
+   * @param {string} connectionName Name of the connection
+   * @param {PostSqlsourceRequest} postSqlsourceRequest SQL statement to execute
+   * @param {string} [_options] Options
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  postQuerydata(a, e, r, t, s) {
+    return S(this.configuration).postQuerydata(a, e, r, t, s).then((o) => o(this.axios, this.basePath));
+  }
+  /**
+   * Creates a Malloy source from a SQL statement using the specified database connection. The SQL statement is executed to generate a source definition that can be used in Malloy models. This is the preferred method over the deprecated GET version as it provides better security and supports larger SQL statements. 
+   * @summary Create SQL source from statement
+   * @param {string} projectName Name of the project
+   * @param {string} connectionName Name of the connection
+   * @param {PostSqlsourceRequest} postSqlsourceRequest SQL statement to fetch the SQL source
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  postSqlsource(a, e, r, t) {
+    return S(this.configuration).postSqlsource(a, e, r, t).then((s) => s(this.axios, this.basePath));
+  }
+  /**
+   * Creates a temporary table from a SQL statement using the specified database connection. This is the preferred method over the deprecated GET version as it provides better security and supports larger SQL statements. Temporary tables are useful for storing intermediate results during complex queries and data processing workflows. 
+   * @summary Create temporary table
+   * @param {string} projectName Name of the project
+   * @param {string} connectionName Name of the connection
+   * @param {PostSqlsourceRequest} postSqlsourceRequest SQL statement to create the temporary table
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  postTemporarytable(a, e, r, t) {
+    return S(this.configuration).postTemporarytable(a, e, r, t).then((s) => s(this.axios, this.basePath));
+  }
+  /**
+   * Tests the connectivity and configuration of an existing database connection within a project. This endpoint validates that the connection can be established, credentials are valid, and the database is accessible. Useful for monitoring connection health and troubleshooting. 
+   * @summary Test existing project connection
+   * @param {string} projectName Name of the project
+   * @param {string} connectionName Name of the connection
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  testConnection(a, e, r) {
+    return S(this.configuration).testConnection(a, e, r).then((t) => t(this.axios, this.basePath));
+  }
+  /**
+   * Validates a database connection configuration without adding it to any project. This endpoint allows you to test connection parameters, credentials, and network connectivity before committing the connection to a project. Useful for troubleshooting connection issues and validating configurations during setup. 
+   * @summary Test database connection configuration
+   * @param {Connection} connection 
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ConnectionsApi
+   */
+  testConnectionConfiguration(a, e) {
+    return S(this.configuration).testConnectionConfiguration(a, e).then((r) => r(this.axios, this.basePath));
+  }
+}
+const J = function(c) {
+  return {
+    /**
+     * Retrieves a list of all embedded databases within the specified package. These are typically DuckDB databases stored as .parquet files that provide local data storage for the package. Each database entry includes metadata about the database structure and content. 
+     * @summary List embedded databases
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listDatabases: async (a, e, r, t = {}) => {
+      d("listDatabases", "projectName", a), d("listDatabases", "packageName", e);
+      const s = "/projects/{projectName}/packages/{packageName}/databases".replace("{projectName}", encodeURIComponent(String(a))).replace("{packageName}", encodeURIComponent(String(e))), o = new URL(s, V);
+      let n;
+      c && (n = c.baseOptions);
+      const l = { method: "GET", ...n, ...t }, i = {}, p = {};
+      r !== void 0 && (p.versionId = r), O(o, p);
+      let h = n && n.headers ? n.headers : {};
+      return l.headers = { ...i, ...h, ...t.headers }, {
+        url: b(o),
+        options: l
+      };
+    }
+  };
+}, T = function(c) {
+  const a = J(c);
+  return {
+    /**
+     * Retrieves a list of all embedded databases within the specified package. These are typically DuckDB databases stored as .parquet files that provide local data storage for the package. Each database entry includes metadata about the database structure and content. 
+     * @summary List embedded databases
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async listDatabases(e, r, t, s) {
+      const o = await a.listDatabases(e, r, t, s), n = c?.serverIndex ?? 0, l = P["DatabasesApi.listDatabases"]?.[n]?.url;
+      return (i, p) => g(o, u, m, c)(i, l || p);
+    }
+  };
+}, je = function(c, a, e) {
+  const r = T(c);
+  return {
+    /**
+     * Retrieves a list of all embedded databases within the specified package. These are typically DuckDB databases stored as .parquet files that provide local data storage for the package. Each database entry includes metadata about the database structure and content. 
+     * @summary List embedded databases
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listDatabases(t, s, o, n) {
+      return r.listDatabases(t, s, o, n).then((l) => l(e, a));
+    }
+  };
+};
+class K extends j {
+  /**
+   * Retrieves a list of all embedded databases within the specified package. These are typically DuckDB databases stored as .parquet files that provide local data storage for the package. Each database entry includes metadata about the database structure and content. 
+   * @summary List embedded databases
+   * @param {string} projectName Name of the project
+   * @param {string} packageName Name of the package
+   * @param {string} [versionId] Version identifier for the package
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof DatabasesApi
+   */
+  listDatabases(a, e, r, t) {
+    return T(this.configuration).listDatabases(a, e, r, t).then((s) => s(this.axios, this.basePath));
+  }
+}
+const Y = function(c) {
+  return {
+    /**
+     * Retrieves a compiled Malloy model with its source information, queries, and metadata. The model is compiled using the specified version of the Malloy compiler. This endpoint provides access to the model\'s structure, sources, and named queries for use in applications. 
+     * @summary Get compiled Malloy model
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} path Path to the model within the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getModel: async (a, e, r, t, s = {}) => {
+      d("getModel", "projectName", a), d("getModel", "packageName", e), d("getModel", "path", r);
+      const o = "/projects/{projectName}/packages/{packageName}/models/{path}".replace("{projectName}", encodeURIComponent(String(a))).replace("{packageName}", encodeURIComponent(String(e))).replace("{path}", encodeURIComponent(String(r))), n = new URL(o, V);
+      let l;
+      c && (l = c.baseOptions);
+      const i = { method: "GET", ...l, ...s }, p = {}, h = {};
+      t !== void 0 && (h.versionId = t), O(n, h);
+      let y = l && l.headers ? l.headers : {};
+      return i.headers = { ...p, ...y, ...s.headers }, {
+        url: b(n),
+        options: i
+      };
+    },
+    /**
+     * Retrieves a list of all Malloy models within the specified package. Each model entry includes the relative path, package name, and any compilation errors. This endpoint is useful for discovering available models and checking their status. 
+     * @summary List package models
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listModels: async (a, e, r, t = {}) => {
+      d("listModels", "projectName", a), d("listModels", "packageName", e);
+      const s = "/projects/{projectName}/packages/{packageName}/models".replace("{projectName}", encodeURIComponent(String(a))).replace("{packageName}", encodeURIComponent(String(e))), o = new URL(s, V);
+      let n;
+      c && (n = c.baseOptions);
+      const l = { method: "GET", ...n, ...t }, i = {}, p = {};
+      r !== void 0 && (p.versionId = r), O(o, p);
+      let h = n && n.headers ? n.headers : {};
+      return l.headers = { ...i, ...h, ...t.headers }, {
+        url: b(o),
+        options: l
+      };
+    }
+  };
+}, I = function(c) {
+  const a = Y(c);
+  return {
+    /**
+     * Retrieves a compiled Malloy model with its source information, queries, and metadata. The model is compiled using the specified version of the Malloy compiler. This endpoint provides access to the model\'s structure, sources, and named queries for use in applications. 
+     * @summary Get compiled Malloy model
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} path Path to the model within the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async getModel(e, r, t, s, o) {
+      const n = await a.getModel(e, r, t, s, o), l = c?.serverIndex ?? 0, i = P["ModelsApi.getModel"]?.[l]?.url;
+      return (p, h) => g(n, u, m, c)(p, i || h);
+    },
+    /**
+     * Retrieves a list of all Malloy models within the specified package. Each model entry includes the relative path, package name, and any compilation errors. This endpoint is useful for discovering available models and checking their status. 
+     * @summary List package models
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async listModels(e, r, t, s) {
+      const o = await a.listModels(e, r, t, s), n = c?.serverIndex ?? 0, l = P["ModelsApi.listModels"]?.[n]?.url;
+      return (i, p) => g(o, u, m, c)(i, l || p);
+    }
+  };
+}, Ae = function(c, a, e) {
+  const r = I(c);
+  return {
+    /**
+     * Retrieves a compiled Malloy model with its source information, queries, and metadata. The model is compiled using the specified version of the Malloy compiler. This endpoint provides access to the model\'s structure, sources, and named queries for use in applications. 
+     * @summary Get compiled Malloy model
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} path Path to the model within the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getModel(t, s, o, n, l) {
+      return r.getModel(t, s, o, n, l).then((i) => i(e, a));
+    },
+    /**
+     * Retrieves a list of all Malloy models within the specified package. Each model entry includes the relative path, package name, and any compilation errors. This endpoint is useful for discovering available models and checking their status. 
+     * @summary List package models
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listModels(t, s, o, n) {
+      return r.listModels(t, s, o, n).then((l) => l(e, a));
+    }
+  };
+};
+class _ extends j {
+  /**
+   * Retrieves a compiled Malloy model with its source information, queries, and metadata. The model is compiled using the specified version of the Malloy compiler. This endpoint provides access to the model\'s structure, sources, and named queries for use in applications. 
+   * @summary Get compiled Malloy model
+   * @param {string} projectName Name of the project
+   * @param {string} packageName Name of the package
+   * @param {string} path Path to the model within the package
+   * @param {string} [versionId] Version identifier for the package
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ModelsApi
+   */
+  getModel(a, e, r, t, s) {
+    return I(this.configuration).getModel(a, e, r, t, s).then((o) => o(this.axios, this.basePath));
+  }
+  /**
+   * Retrieves a list of all Malloy models within the specified package. Each model entry includes the relative path, package name, and any compilation errors. This endpoint is useful for discovering available models and checking their status. 
+   * @summary List package models
+   * @param {string} projectName Name of the project
+   * @param {string} packageName Name of the package
+   * @param {string} [versionId] Version identifier for the package
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ModelsApi
+   */
+  listModels(a, e, r, t) {
+    return I(this.configuration).listModels(a, e, r, t).then((s) => s(this.axios, this.basePath));
+  }
+}
+const X = function(c) {
+  return {
+    /**
+     * Retrieves a compiled Malloy notebook with its cells, results, and metadata. The notebook is compiled using the specified version of the Malloy compiler. This endpoint provides access to the notebook\'s structure, cells, and execution results for use in applications. 
+     * @summary Get compiled Malloy notebook
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} path Path to notebook within the package.
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getNotebook: async (a, e, r, t, s = {}) => {
+      d("getNotebook", "projectName", a), d("getNotebook", "packageName", e), d("getNotebook", "path", r);
+      const o = "/projects/{projectName}/packages/{packageName}/notebooks/{path}".replace("{projectName}", encodeURIComponent(String(a))).replace("{packageName}", encodeURIComponent(String(e))).replace("{path}", encodeURIComponent(String(r))), n = new URL(o, V);
+      let l;
+      c && (l = c.baseOptions);
+      const i = { method: "GET", ...l, ...s }, p = {}, h = {};
+      t !== void 0 && (h.versionId = t), O(n, h);
+      let y = l && l.headers ? l.headers : {};
+      return i.headers = { ...p, ...y, ...s.headers }, {
+        url: b(n),
+        options: i
+      };
+    },
+    /**
+     * Retrieves a list of all Malloy notebooks within the specified package. Each notebook entry includes the relative path, package name, and any compilation errors. This endpoint is useful for discovering available notebooks and checking their status. 
+     * @summary List package notebooks
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listNotebooks: async (a, e, r, t = {}) => {
+      d("listNotebooks", "projectName", a), d("listNotebooks", "packageName", e);
+      const s = "/projects/{projectName}/packages/{packageName}/notebooks".replace("{projectName}", encodeURIComponent(String(a))).replace("{packageName}", encodeURIComponent(String(e))), o = new URL(s, V);
+      let n;
+      c && (n = c.baseOptions);
+      const l = { method: "GET", ...n, ...t }, i = {}, p = {};
+      r !== void 0 && (p.versionId = r), O(o, p);
+      let h = n && n.headers ? n.headers : {};
+      return l.headers = { ...i, ...h, ...t.headers }, {
+        url: b(o),
+        options: l
+      };
+    }
+  };
+}, U = function(c) {
+  const a = X(c);
+  return {
+    /**
+     * Retrieves a compiled Malloy notebook with its cells, results, and metadata. The notebook is compiled using the specified version of the Malloy compiler. This endpoint provides access to the notebook\'s structure, cells, and execution results for use in applications. 
+     * @summary Get compiled Malloy notebook
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} path Path to notebook within the package.
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async getNotebook(e, r, t, s, o) {
+      const n = await a.getNotebook(e, r, t, s, o), l = c?.serverIndex ?? 0, i = P["NotebooksApi.getNotebook"]?.[l]?.url;
+      return (p, h) => g(n, u, m, c)(p, i || h);
+    },
+    /**
+     * Retrieves a list of all Malloy notebooks within the specified package. Each notebook entry includes the relative path, package name, and any compilation errors. This endpoint is useful for discovering available notebooks and checking their status. 
+     * @summary List package notebooks
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async listNotebooks(e, r, t, s) {
+      const o = await a.listNotebooks(e, r, t, s), n = c?.serverIndex ?? 0, l = P["NotebooksApi.listNotebooks"]?.[n]?.url;
+      return (i, p) => g(o, u, m, c)(i, l || p);
+    }
+  };
+}, xe = function(c, a, e) {
+  const r = U(c);
+  return {
+    /**
+     * Retrieves a compiled Malloy notebook with its cells, results, and metadata. The notebook is compiled using the specified version of the Malloy compiler. This endpoint provides access to the notebook\'s structure, cells, and execution results for use in applications. 
+     * @summary Get compiled Malloy notebook
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} path Path to notebook within the package.
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getNotebook(t, s, o, n, l) {
+      return r.getNotebook(t, s, o, n, l).then((i) => i(e, a));
+    },
+    /**
+     * Retrieves a list of all Malloy notebooks within the specified package. Each notebook entry includes the relative path, package name, and any compilation errors. This endpoint is useful for discovering available notebooks and checking their status. 
+     * @summary List package notebooks
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listNotebooks(t, s, o, n) {
+      return r.listNotebooks(t, s, o, n).then((l) => l(e, a));
+    }
+  };
+};
+class Z extends j {
+  /**
+   * Retrieves a compiled Malloy notebook with its cells, results, and metadata. The notebook is compiled using the specified version of the Malloy compiler. This endpoint provides access to the notebook\'s structure, cells, and execution results for use in applications. 
+   * @summary Get compiled Malloy notebook
+   * @param {string} projectName Name of the project
+   * @param {string} packageName Name of the package
+   * @param {string} path Path to notebook within the package.
+   * @param {string} [versionId] Version identifier for the package
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof NotebooksApi
+   */
+  getNotebook(a, e, r, t, s) {
+    return U(this.configuration).getNotebook(a, e, r, t, s).then((o) => o(this.axios, this.basePath));
+  }
+  /**
+   * Retrieves a list of all Malloy notebooks within the specified package. Each notebook entry includes the relative path, package name, and any compilation errors. This endpoint is useful for discovering available notebooks and checking their status. 
+   * @summary List package notebooks
+   * @param {string} projectName Name of the project
+   * @param {string} packageName Name of the package
+   * @param {string} [versionId] Version identifier for the package
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof NotebooksApi
+   */
+  listNotebooks(a, e, r, t) {
+    return U(this.configuration).listNotebooks(a, e, r, t).then((s) => s(this.axios, this.basePath));
+  }
+}
+const ee = function(c) {
+  return {
+    /**
+     * Creates a new Malloy package within the specified project. A package serves as a container for models, notebooks, embedded databases, and other resources. The package will be initialized with the provided metadata and can immediately accept content. 
+     * @summary Create a new package
+     * @param {string} projectName Name of the project
+     * @param {Package} _package 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    createPackage: async (a, e, r = {}) => {
+      d("createPackage", "projectName", a), d("createPackage", "_package", e);
+      const t = "/projects/{projectName}/packages".replace("{projectName}", encodeURIComponent(String(a))), s = new URL(t, V);
+      let o;
+      c && (o = c.baseOptions);
+      const n = { method: "POST", ...o, ...r }, l = {}, i = {};
+      l["Content-Type"] = "application/json", O(s, i);
+      let p = o && o.headers ? o.headers : {};
+      return n.headers = { ...l, ...p, ...r.headers }, n.data = A(e, n, c), {
+        url: b(s),
+        options: n
+      };
+    },
+    /**
+     * Permanently deletes a package and all its associated resources including models, notebooks, databases, and metadata. This operation cannot be undone, so use with caution. The package must exist and be accessible for deletion. 
+     * @summary Delete a package
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    deletePackage: async (a, e, r = {}) => {
+      d("deletePackage", "projectName", a), d("deletePackage", "packageName", e);
+      const t = "/projects/{projectName}/packages/{packageName}".replace("{projectName}", encodeURIComponent(String(a))).replace("{packageName}", encodeURIComponent(String(e))), s = new URL(t, V);
+      let o;
+      c && (o = c.baseOptions);
+      const n = { method: "DELETE", ...o, ...r }, l = {};
+      O(s, {});
+      let p = o && o.headers ? o.headers : {};
+      return n.headers = { ...l, ...p, ...r.headers }, {
+        url: b(s),
+        options: n
+      };
+    },
+    /**
+     * Retrieves detailed information about a specific package, including its models, notebooks, databases, and metadata. The reload parameter can be used to refresh the package state from disk before returning the information. The versionId parameter allows access to specific package versions. 
+     * @summary Get package details and metadata
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Package name
+     * @param {string} [versionId] Version identifier for the package
+     * @param {boolean} [reload] Load / reload the package before returning result
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getPackage: async (a, e, r, t, s = {}) => {
+      d("getPackage", "projectName", a), d("getPackage", "packageName", e);
+      const o = "/projects/{projectName}/packages/{packageName}".replace("{projectName}", encodeURIComponent(String(a))).replace("{packageName}", encodeURIComponent(String(e))), n = new URL(o, V);
+      let l;
+      c && (l = c.baseOptions);
+      const i = { method: "GET", ...l, ...s }, p = {}, h = {};
+      r !== void 0 && (h.versionId = r), t !== void 0 && (h.reload = t), O(n, h);
+      let y = l && l.headers ? l.headers : {};
+      return i.headers = { ...p, ...y, ...s.headers }, {
+        url: b(n),
+        options: i
+      };
+    },
+    /**
+     * Retrieves a list of all Malloy packages within the specified project. Each package contains models, notebooks, databases, and other resources. This endpoint is useful for discovering available packages and their basic metadata. 
+     * @summary List project packages
+     * @param {string} projectName Name of the project
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listPackages: async (a, e = {}) => {
+      d("listPackages", "projectName", a);
+      const r = "/projects/{projectName}/packages".replace("{projectName}", encodeURIComponent(String(a))), t = new URL(r, V);
+      let s;
+      c && (s = c.baseOptions);
+      const o = { method: "GET", ...s, ...e }, n = {};
+      O(t, {});
+      let i = s && s.headers ? s.headers : {};
+      return o.headers = { ...n, ...i, ...e.headers }, {
+        url: b(t),
+        options: o
+      };
+    },
+    /**
+     * Updates the configuration and metadata of an existing package. This allows you to modify package settings, update the description, change the location, or update other package-level properties. The package must exist and be accessible. 
+     * @summary Update package configuration
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {Package} _package 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    updatePackage: async (a, e, r, t = {}) => {
+      d("updatePackage", "projectName", a), d("updatePackage", "packageName", e), d("updatePackage", "_package", r);
+      const s = "/projects/{projectName}/packages/{packageName}".replace("{projectName}", encodeURIComponent(String(a))).replace("{packageName}", encodeURIComponent(String(e))), o = new URL(s, V);
+      let n;
+      c && (n = c.baseOptions);
+      const l = { method: "PATCH", ...n, ...t }, i = {}, p = {};
+      i["Content-Type"] = "application/json", O(o, p);
+      let h = n && n.headers ? n.headers : {};
+      return l.headers = { ...i, ...h, ...t.headers }, l.data = A(r, l, c), {
+        url: b(o),
+        options: l
+      };
+    }
+  };
+}, C = function(c) {
+  const a = ee(c);
+  return {
+    /**
+     * Creates a new Malloy package within the specified project. A package serves as a container for models, notebooks, embedded databases, and other resources. The package will be initialized with the provided metadata and can immediately accept content. 
+     * @summary Create a new package
+     * @param {string} projectName Name of the project
+     * @param {Package} _package 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async createPackage(e, r, t) {
+      const s = await a.createPackage(e, r, t), o = c?.serverIndex ?? 0, n = P["PackagesApi.createPackage"]?.[o]?.url;
+      return (l, i) => g(s, u, m, c)(l, n || i);
+    },
+    /**
+     * Permanently deletes a package and all its associated resources including models, notebooks, databases, and metadata. This operation cannot be undone, so use with caution. The package must exist and be accessible for deletion. 
+     * @summary Delete a package
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async deletePackage(e, r, t) {
+      const s = await a.deletePackage(e, r, t), o = c?.serverIndex ?? 0, n = P["PackagesApi.deletePackage"]?.[o]?.url;
+      return (l, i) => g(s, u, m, c)(l, n || i);
+    },
+    /**
+     * Retrieves detailed information about a specific package, including its models, notebooks, databases, and metadata. The reload parameter can be used to refresh the package state from disk before returning the information. The versionId parameter allows access to specific package versions. 
+     * @summary Get package details and metadata
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Package name
+     * @param {string} [versionId] Version identifier for the package
+     * @param {boolean} [reload] Load / reload the package before returning result
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async getPackage(e, r, t, s, o) {
+      const n = await a.getPackage(e, r, t, s, o), l = c?.serverIndex ?? 0, i = P["PackagesApi.getPackage"]?.[l]?.url;
+      return (p, h) => g(n, u, m, c)(p, i || h);
+    },
+    /**
+     * Retrieves a list of all Malloy packages within the specified project. Each package contains models, notebooks, databases, and other resources. This endpoint is useful for discovering available packages and their basic metadata. 
+     * @summary List project packages
+     * @param {string} projectName Name of the project
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async listPackages(e, r) {
+      const t = await a.listPackages(e, r), s = c?.serverIndex ?? 0, o = P["PackagesApi.listPackages"]?.[s]?.url;
+      return (n, l) => g(t, u, m, c)(n, o || l);
+    },
+    /**
+     * Updates the configuration and metadata of an existing package. This allows you to modify package settings, update the description, change the location, or update other package-level properties. The package must exist and be accessible. 
+     * @summary Update package configuration
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {Package} _package 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async updatePackage(e, r, t, s) {
+      const o = await a.updatePackage(e, r, t, s), n = c?.serverIndex ?? 0, l = P["PackagesApi.updatePackage"]?.[n]?.url;
+      return (i, p) => g(o, u, m, c)(i, l || p);
+    }
+  };
+}, Ce = function(c, a, e) {
+  const r = C(c);
+  return {
+    /**
+     * Creates a new Malloy package within the specified project. A package serves as a container for models, notebooks, embedded databases, and other resources. The package will be initialized with the provided metadata and can immediately accept content. 
+     * @summary Create a new package
+     * @param {string} projectName Name of the project
+     * @param {Package} _package 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    createPackage(t, s, o) {
+      return r.createPackage(t, s, o).then((n) => n(e, a));
+    },
+    /**
+     * Permanently deletes a package and all its associated resources including models, notebooks, databases, and metadata. This operation cannot be undone, so use with caution. The package must exist and be accessible for deletion. 
+     * @summary Delete a package
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    deletePackage(t, s, o) {
+      return r.deletePackage(t, s, o).then((n) => n(e, a));
+    },
+    /**
+     * Retrieves detailed information about a specific package, including its models, notebooks, databases, and metadata. The reload parameter can be used to refresh the package state from disk before returning the information. The versionId parameter allows access to specific package versions. 
+     * @summary Get package details and metadata
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Package name
+     * @param {string} [versionId] Version identifier for the package
+     * @param {boolean} [reload] Load / reload the package before returning result
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getPackage(t, s, o, n, l) {
+      return r.getPackage(t, s, o, n, l).then((i) => i(e, a));
+    },
+    /**
+     * Retrieves a list of all Malloy packages within the specified project. Each package contains models, notebooks, databases, and other resources. This endpoint is useful for discovering available packages and their basic metadata. 
+     * @summary List project packages
+     * @param {string} projectName Name of the project
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listPackages(t, s) {
+      return r.listPackages(t, s).then((o) => o(e, a));
+    },
+    /**
+     * Updates the configuration and metadata of an existing package. This allows you to modify package settings, update the description, change the location, or update other package-level properties. The package must exist and be accessible. 
+     * @summary Update package configuration
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {Package} _package 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    updatePackage(t, s, o, n) {
+      return r.updatePackage(t, s, o, n).then((l) => l(e, a));
+    }
+  };
+};
+class te extends j {
+  /**
+   * Creates a new Malloy package within the specified project. A package serves as a container for models, notebooks, embedded databases, and other resources. The package will be initialized with the provided metadata and can immediately accept content. 
+   * @summary Create a new package
+   * @param {string} projectName Name of the project
+   * @param {Package} _package 
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof PackagesApi
+   */
+  createPackage(a, e, r) {
+    return C(this.configuration).createPackage(a, e, r).then((t) => t(this.axios, this.basePath));
+  }
+  /**
+   * Permanently deletes a package and all its associated resources including models, notebooks, databases, and metadata. This operation cannot be undone, so use with caution. The package must exist and be accessible for deletion. 
+   * @summary Delete a package
+   * @param {string} projectName Name of the project
+   * @param {string} packageName Name of the package
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof PackagesApi
+   */
+  deletePackage(a, e, r) {
+    return C(this.configuration).deletePackage(a, e, r).then((t) => t(this.axios, this.basePath));
+  }
+  /**
+   * Retrieves detailed information about a specific package, including its models, notebooks, databases, and metadata. The reload parameter can be used to refresh the package state from disk before returning the information. The versionId parameter allows access to specific package versions. 
+   * @summary Get package details and metadata
+   * @param {string} projectName Name of the project
+   * @param {string} packageName Package name
+   * @param {string} [versionId] Version identifier for the package
+   * @param {boolean} [reload] Load / reload the package before returning result
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof PackagesApi
+   */
+  getPackage(a, e, r, t, s) {
+    return C(this.configuration).getPackage(a, e, r, t, s).then((o) => o(this.axios, this.basePath));
+  }
+  /**
+   * Retrieves a list of all Malloy packages within the specified project. Each package contains models, notebooks, databases, and other resources. This endpoint is useful for discovering available packages and their basic metadata. 
+   * @summary List project packages
+   * @param {string} projectName Name of the project
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof PackagesApi
+   */
+  listPackages(a, e) {
+    return C(this.configuration).listPackages(a, e).then((r) => r(this.axios, this.basePath));
+  }
+  /**
+   * Updates the configuration and metadata of an existing package. This allows you to modify package settings, update the description, change the location, or update other package-level properties. The package must exist and be accessible. 
+   * @summary Update package configuration
+   * @param {string} projectName Name of the project
+   * @param {string} packageName Name of the package
+   * @param {Package} _package 
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof PackagesApi
+   */
+  updatePackage(a, e, r, t) {
+    return C(this.configuration).updatePackage(a, e, r, t).then((s) => s(this.axios, this.basePath));
+  }
+}
+const ae = function(c) {
+  return {
+    /**
+     * Creates a new Malloy project with the specified configuration. A project serves as a container for packages, connections, and other resources. The project will be initialized with the provided metadata and can immediately accept packages and connections. 
+     * @summary Create a new project
+     * @param {Project} project 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    createProject: async (a, e = {}) => {
+      d("createProject", "project", a);
+      const r = "/projects", t = new URL(r, V);
+      let s;
+      c && (s = c.baseOptions);
+      const o = { method: "POST", ...s, ...e }, n = {}, l = {};
+      n["Content-Type"] = "application/json", O(t, l);
+      let i = s && s.headers ? s.headers : {};
+      return o.headers = { ...n, ...i, ...e.headers }, o.data = A(a, o, c), {
+        url: b(t),
+        options: o
+      };
+    },
+    /**
+     * Permanently deletes a project and all its associated resources including packages, connections, and metadata. This operation cannot be undone, so use with caution. The project must exist and be accessible for deletion. 
+     * @summary Delete a project
+     * @param {string} projectName Name of the project
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    deleteProject: async (a, e = {}) => {
+      d("deleteProject", "projectName", a);
+      const r = "/projects/{projectName}".replace("{projectName}", encodeURIComponent(String(a))), t = new URL(r, V);
+      let s;
+      c && (s = c.baseOptions);
+      const o = { method: "DELETE", ...s, ...e }, n = {};
+      O(t, {});
+      let i = s && s.headers ? s.headers : {};
+      return o.headers = { ...n, ...i, ...e.headers }, {
+        url: b(t),
+        options: o
+      };
+    },
+    /**
+     * Retrieves detailed information about a specific project, including its packages, connections, configuration, and metadata. The reload parameter can be used to refresh the project state from disk before returning the information. 
+     * @summary Get project details and metadata
+     * @param {string} projectName Name of the project
+     * @param {boolean} [reload] Load / reload the project before returning result
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getProject: async (a, e, r = {}) => {
+      d("getProject", "projectName", a);
+      const t = "/projects/{projectName}".replace("{projectName}", encodeURIComponent(String(a))), s = new URL(t, V);
+      let o;
+      c && (o = c.baseOptions);
+      const n = { method: "GET", ...o, ...r }, l = {}, i = {};
+      e !== void 0 && (i.reload = e), O(s, i);
+      let p = o && o.headers ? o.headers : {};
+      return n.headers = { ...l, ...p, ...r.headers }, {
+        url: b(s),
+        options: n
+      };
+    },
+    /**
+     * Retrieves a list of all projects currently hosted on this Malloy Publisher server. Each project contains metadata about its packages, connections, and configuration. This endpoint is typically used to discover available projects and their basic information. 
+     * @summary List all available projects
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listProjects: async (a = {}) => {
+      const e = "/projects", r = new URL(e, V);
+      let t;
+      c && (t = c.baseOptions);
+      const s = { method: "GET", ...t, ...a }, o = {};
+      O(r, {});
+      let l = t && t.headers ? t.headers : {};
+      return s.headers = { ...o, ...l, ...a.headers }, {
+        url: b(r),
+        options: s
+      };
+    },
+    /**
+     * Updates the configuration and metadata of an existing project. This allows you to modify project settings, update the README, change the location, or update other project-level properties. The project must exist and be accessible. 
+     * @summary Update project configuration
+     * @param {string} projectName Name of the project
+     * @param {Project} project 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    updateProject: async (a, e, r = {}) => {
+      d("updateProject", "projectName", a), d("updateProject", "project", e);
+      const t = "/projects/{projectName}".replace("{projectName}", encodeURIComponent(String(a))), s = new URL(t, V);
+      let o;
+      c && (o = c.baseOptions);
+      const n = { method: "PATCH", ...o, ...r }, l = {}, i = {};
+      l["Content-Type"] = "application/json", O(s, i);
+      let p = o && o.headers ? o.headers : {};
+      return n.headers = { ...l, ...p, ...r.headers }, n.data = A(e, n, c), {
+        url: b(s),
+        options: n
+      };
+    }
+  };
+}, v = function(c) {
+  const a = ae(c);
+  return {
+    /**
+     * Creates a new Malloy project with the specified configuration. A project serves as a container for packages, connections, and other resources. The project will be initialized with the provided metadata and can immediately accept packages and connections. 
+     * @summary Create a new project
+     * @param {Project} project 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async createProject(e, r) {
+      const t = await a.createProject(e, r), s = c?.serverIndex ?? 0, o = P["ProjectsApi.createProject"]?.[s]?.url;
+      return (n, l) => g(t, u, m, c)(n, o || l);
+    },
+    /**
+     * Permanently deletes a project and all its associated resources including packages, connections, and metadata. This operation cannot be undone, so use with caution. The project must exist and be accessible for deletion. 
+     * @summary Delete a project
+     * @param {string} projectName Name of the project
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async deleteProject(e, r) {
+      const t = await a.deleteProject(e, r), s = c?.serverIndex ?? 0, o = P["ProjectsApi.deleteProject"]?.[s]?.url;
+      return (n, l) => g(t, u, m, c)(n, o || l);
+    },
+    /**
+     * Retrieves detailed information about a specific project, including its packages, connections, configuration, and metadata. The reload parameter can be used to refresh the project state from disk before returning the information. 
+     * @summary Get project details and metadata
+     * @param {string} projectName Name of the project
+     * @param {boolean} [reload] Load / reload the project before returning result
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async getProject(e, r, t) {
+      const s = await a.getProject(e, r, t), o = c?.serverIndex ?? 0, n = P["ProjectsApi.getProject"]?.[o]?.url;
+      return (l, i) => g(s, u, m, c)(l, n || i);
+    },
+    /**
+     * Retrieves a list of all projects currently hosted on this Malloy Publisher server. Each project contains metadata about its packages, connections, and configuration. This endpoint is typically used to discover available projects and their basic information. 
+     * @summary List all available projects
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async listProjects(e) {
+      const r = await a.listProjects(e), t = c?.serverIndex ?? 0, s = P["ProjectsApi.listProjects"]?.[t]?.url;
+      return (o, n) => g(r, u, m, c)(o, s || n);
+    },
+    /**
+     * Updates the configuration and metadata of an existing project. This allows you to modify project settings, update the README, change the location, or update other project-level properties. The project must exist and be accessible. 
+     * @summary Update project configuration
+     * @param {string} projectName Name of the project
+     * @param {Project} project 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async updateProject(e, r, t) {
+      const s = await a.updateProject(e, r, t), o = c?.serverIndex ?? 0, n = P["ProjectsApi.updateProject"]?.[o]?.url;
+      return (l, i) => g(s, u, m, c)(l, n || i);
+    }
+  };
+}, ve = function(c, a, e) {
+  const r = v(c);
+  return {
+    /**
+     * Creates a new Malloy project with the specified configuration. A project serves as a container for packages, connections, and other resources. The project will be initialized with the provided metadata and can immediately accept packages and connections. 
+     * @summary Create a new project
+     * @param {Project} project 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    createProject(t, s) {
+      return r.createProject(t, s).then((o) => o(e, a));
+    },
+    /**
+     * Permanently deletes a project and all its associated resources including packages, connections, and metadata. This operation cannot be undone, so use with caution. The project must exist and be accessible for deletion. 
+     * @summary Delete a project
+     * @param {string} projectName Name of the project
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    deleteProject(t, s) {
+      return r.deleteProject(t, s).then((o) => o(e, a));
+    },
+    /**
+     * Retrieves detailed information about a specific project, including its packages, connections, configuration, and metadata. The reload parameter can be used to refresh the project state from disk before returning the information. 
+     * @summary Get project details and metadata
+     * @param {string} projectName Name of the project
+     * @param {boolean} [reload] Load / reload the project before returning result
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getProject(t, s, o) {
+      return r.getProject(t, s, o).then((n) => n(e, a));
+    },
+    /**
+     * Retrieves a list of all projects currently hosted on this Malloy Publisher server. Each project contains metadata about its packages, connections, and configuration. This endpoint is typically used to discover available projects and their basic information. 
+     * @summary List all available projects
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listProjects(t) {
+      return r.listProjects(t).then((s) => s(e, a));
+    },
+    /**
+     * Updates the configuration and metadata of an existing project. This allows you to modify project settings, update the README, change the location, or update other project-level properties. The project must exist and be accessible. 
+     * @summary Update project configuration
+     * @param {string} projectName Name of the project
+     * @param {Project} project 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    updateProject(t, s, o) {
+      return r.updateProject(t, s, o).then((n) => n(e, a));
+    }
+  };
+};
+class re extends j {
+  /**
+   * Creates a new Malloy project with the specified configuration. A project serves as a container for packages, connections, and other resources. The project will be initialized with the provided metadata and can immediately accept packages and connections. 
+   * @summary Create a new project
+   * @param {Project} project 
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ProjectsApi
+   */
+  createProject(a, e) {
+    return v(this.configuration).createProject(a, e).then((r) => r(this.axios, this.basePath));
+  }
+  /**
+   * Permanently deletes a project and all its associated resources including packages, connections, and metadata. This operation cannot be undone, so use with caution. The project must exist and be accessible for deletion. 
+   * @summary Delete a project
+   * @param {string} projectName Name of the project
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ProjectsApi
+   */
+  deleteProject(a, e) {
+    return v(this.configuration).deleteProject(a, e).then((r) => r(this.axios, this.basePath));
+  }
+  /**
+   * Retrieves detailed information about a specific project, including its packages, connections, configuration, and metadata. The reload parameter can be used to refresh the project state from disk before returning the information. 
+   * @summary Get project details and metadata
+   * @param {string} projectName Name of the project
+   * @param {boolean} [reload] Load / reload the project before returning result
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ProjectsApi
+   */
+  getProject(a, e, r) {
+    return v(this.configuration).getProject(a, e, r).then((t) => t(this.axios, this.basePath));
+  }
+  /**
+   * Retrieves a list of all projects currently hosted on this Malloy Publisher server. Each project contains metadata about its packages, connections, and configuration. This endpoint is typically used to discover available projects and their basic information. 
+   * @summary List all available projects
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ProjectsApi
+   */
+  listProjects(a) {
+    return v(this.configuration).listProjects(a).then((e) => e(this.axios, this.basePath));
+  }
+  /**
+   * Updates the configuration and metadata of an existing project. This allows you to modify project settings, update the README, change the location, or update other project-level properties. The project must exist and be accessible. 
+   * @summary Update project configuration
+   * @param {string} projectName Name of the project
+   * @param {Project} project 
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof ProjectsApi
+   */
+  updateProject(a, e, r) {
+    return v(this.configuration).updateProject(a, e, r).then((t) => t(this.axios, this.basePath));
+  }
+}
+const se = function(c) {
+  return {
+    /**
+     * Returns the current status of the Malloy Publisher server, including initialization state, available projects, and server timestamp. This endpoint is useful for health checks and monitoring server availability. 
+     * @summary Get server status and health information
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getStatus: async (a = {}) => {
+      const e = "/status", r = new URL(e, V);
+      let t;
+      c && (t = c.baseOptions);
+      const s = { method: "GET", ...t, ...a }, o = {};
+      O(r, {});
+      let l = t && t.headers ? t.headers : {};
+      return s.headers = { ...o, ...l, ...a.headers }, {
+        url: b(r),
+        options: s
+      };
+    }
+  };
+}, Q = function(c) {
+  const a = se(c);
+  return {
+    /**
+     * Returns the current status of the Malloy Publisher server, including initialization state, available projects, and server timestamp. This endpoint is useful for health checks and monitoring server availability. 
+     * @summary Get server status and health information
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async getStatus(e) {
+      const r = await a.getStatus(e), t = c?.serverIndex ?? 0, s = P["PublisherApi.getStatus"]?.[t]?.url;
+      return (o, n) => g(r, u, m, c)(o, s || n);
+    }
+  };
+}, Re = function(c, a, e) {
+  const r = Q(c);
+  return {
+    /**
+     * Returns the current status of the Malloy Publisher server, including initialization state, available projects, and server timestamp. This endpoint is useful for health checks and monitoring server availability. 
+     * @summary Get server status and health information
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getStatus(t) {
+      return r.getStatus(t).then((s) => s(e, a));
+    }
+  };
+};
+class ke extends j {
+  /**
+   * Returns the current status of the Malloy Publisher server, including initialization state, available projects, and server timestamp. This endpoint is useful for health checks and monitoring server availability. 
+   * @summary Get server status and health information
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof PublisherApi
+   */
+  getStatus(a) {
+    return Q(this.configuration).getStatus(a).then((e) => e(this.axios, this.basePath));
+  }
+}
+const oe = function(c) {
+  return {
+    /**
+     * Executes a Malloy query against a model and returns the results. The query can be specified as a raw Malloy query string or by referencing a named query within the model. This endpoint supports both ad-hoc queries and predefined model queries, making it flexible for various use cases including data exploration, reporting, and application integration. 
+     * @summary Execute Malloy query
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} path Path to the model within the package
+     * @param {string} [query] Query string to execute on the model. If the query parameter is set, the queryName parameter must be empty.
+     * @param {string} [sourceName] Name of the source in the model to use for queryName, search, and topValue requests.
+     * @param {string} [queryName] Name of a query to execute on a source in the model. Requires the sourceName parameter is set. If the queryName parameter is set, the query parameter must be empty.
+     * @param {string} [versionId] Version ID
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    executeQuery: async (a, e, r, t, s, o, n, l = {}) => {
+      d("executeQuery", "projectName", a), d("executeQuery", "packageName", e), d("executeQuery", "path", r);
+      const i = "/projects/{projectName}/packages/{packageName}/queryResults/{path}".replace("{projectName}", encodeURIComponent(String(a))).replace("{packageName}", encodeURIComponent(String(e))).replace("{path}", encodeURIComponent(String(r))), p = new URL(i, V);
+      let h;
+      c && (h = c.baseOptions);
+      const y = { method: "GET", ...h, ...l }, k = {}, x = {};
+      t !== void 0 && (x.query = t), s !== void 0 && (x.sourceName = s), o !== void 0 && (x.queryName = o), n !== void 0 && (x.versionId = n), O(p, x);
+      let $ = h && h.headers ? h.headers : {};
+      return y.headers = { ...k, ...$, ...l.headers }, {
+        url: b(p),
+        options: y
+      };
+    }
+  };
+}, q = function(c) {
+  const a = oe(c);
+  return {
+    /**
+     * Executes a Malloy query against a model and returns the results. The query can be specified as a raw Malloy query string or by referencing a named query within the model. This endpoint supports both ad-hoc queries and predefined model queries, making it flexible for various use cases including data exploration, reporting, and application integration. 
+     * @summary Execute Malloy query
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} path Path to the model within the package
+     * @param {string} [query] Query string to execute on the model. If the query parameter is set, the queryName parameter must be empty.
+     * @param {string} [sourceName] Name of the source in the model to use for queryName, search, and topValue requests.
+     * @param {string} [queryName] Name of a query to execute on a source in the model. Requires the sourceName parameter is set. If the queryName parameter is set, the query parameter must be empty.
+     * @param {string} [versionId] Version ID
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async executeQuery(e, r, t, s, o, n, l, i) {
+      const p = await a.executeQuery(e, r, t, s, o, n, l, i), h = c?.serverIndex ?? 0, y = P["QueryresultsApi.executeQuery"]?.[h]?.url;
+      return (k, x) => g(p, u, m, c)(k, y || x);
+    }
+  };
+}, Ne = function(c, a, e) {
+  const r = q(c);
+  return {
+    /**
+     * Executes a Malloy query against a model and returns the results. The query can be specified as a raw Malloy query string or by referencing a named query within the model. This endpoint supports both ad-hoc queries and predefined model queries, making it flexible for various use cases including data exploration, reporting, and application integration. 
+     * @summary Execute Malloy query
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} path Path to the model within the package
+     * @param {string} [query] Query string to execute on the model. If the query parameter is set, the queryName parameter must be empty.
+     * @param {string} [sourceName] Name of the source in the model to use for queryName, search, and topValue requests.
+     * @param {string} [queryName] Name of a query to execute on a source in the model. Requires the sourceName parameter is set. If the queryName parameter is set, the query parameter must be empty.
+     * @param {string} [versionId] Version ID
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    executeQuery(t, s, o, n, l, i, p, h) {
+      return r.executeQuery(t, s, o, n, l, i, p, h).then((y) => y(e, a));
+    }
+  };
+};
+class ne extends j {
+  /**
+   * Executes a Malloy query against a model and returns the results. The query can be specified as a raw Malloy query string or by referencing a named query within the model. This endpoint supports both ad-hoc queries and predefined model queries, making it flexible for various use cases including data exploration, reporting, and application integration. 
+   * @summary Execute Malloy query
+   * @param {string} projectName Name of the project
+   * @param {string} packageName Name of the package
+   * @param {string} path Path to the model within the package
+   * @param {string} [query] Query string to execute on the model. If the query parameter is set, the queryName parameter must be empty.
+   * @param {string} [sourceName] Name of the source in the model to use for queryName, search, and topValue requests.
+   * @param {string} [queryName] Name of a query to execute on a source in the model. Requires the sourceName parameter is set. If the queryName parameter is set, the query parameter must be empty.
+   * @param {string} [versionId] Version ID
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof QueryresultsApi
+   */
+  executeQuery(a, e, r, t, s, o, n, l) {
+    return q(this.configuration).executeQuery(a, e, r, t, s, o, n, l).then((i) => i(this.axios, this.basePath));
+  }
+}
+const ce = function(c) {
+  return {
+    /**
+     * Retrieves a list of all scheduled tasks associated with the specified package. These schedules define automated operations such as data refresh, report generation, or other recurring tasks. Each schedule includes timing information and execution status. 
+     * @summary List package schedules
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listSchedules: async (a, e, r, t = {}) => {
+      d("listSchedules", "projectName", a), d("listSchedules", "packageName", e);
+      const s = "/projects/{projectName}/packages/{packageName}/schedules".replace("{projectName}", encodeURIComponent(String(a))).replace("{packageName}", encodeURIComponent(String(e))), o = new URL(s, V);
+      let n;
+      c && (n = c.baseOptions);
+      const l = { method: "GET", ...n, ...t }, i = {}, p = {};
+      r !== void 0 && (p.versionId = r), O(o, p);
+      let h = n && n.headers ? n.headers : {};
+      return l.headers = { ...i, ...h, ...t.headers }, {
+        url: b(o),
+        options: l
+      };
+    }
+  };
+}, B = function(c) {
+  const a = ce(c);
+  return {
+    /**
+     * Retrieves a list of all scheduled tasks associated with the specified package. These schedules define automated operations such as data refresh, report generation, or other recurring tasks. Each schedule includes timing information and execution status. 
+     * @summary List package schedules
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async listSchedules(e, r, t, s) {
+      const o = await a.listSchedules(e, r, t, s), n = c?.serverIndex ?? 0, l = P["SchedulesApi.listSchedules"]?.[n]?.url;
+      return (i, p) => g(o, u, m, c)(i, l || p);
+    }
+  };
+}, Ie = function(c, a, e) {
+  const r = B(c);
+  return {
+    /**
+     * Retrieves a list of all scheduled tasks associated with the specified package. These schedules define automated operations such as data refresh, report generation, or other recurring tasks. Each schedule includes timing information and execution status. 
+     * @summary List package schedules
+     * @param {string} projectName Name of the project
+     * @param {string} packageName Name of the package
+     * @param {string} [versionId] Version identifier for the package
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    listSchedules(t, s, o, n) {
+      return r.listSchedules(t, s, o, n).then((l) => l(e, a));
+    }
+  };
+};
+class le extends j {
+  /**
+   * Retrieves a list of all scheduled tasks associated with the specified package. These schedules define automated operations such as data refresh, report generation, or other recurring tasks. Each schedule includes timing information and execution status. 
+   * @summary List package schedules
+   * @param {string} projectName Name of the project
+   * @param {string} packageName Name of the package
+   * @param {string} [versionId] Version identifier for the package
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof SchedulesApi
+   */
+  listSchedules(a, e, r, t) {
+    return B(this.configuration).listSchedules(a, e, r, t).then((s) => s(this.axios, this.basePath));
+  }
+}
+const ie = function(c) {
+  return {
+    /**
+     * Retrieves the current status of the file watching system. This includes whether watch mode is enabled, which project is being watched, and the path being monitored. Useful for monitoring the development workflow and ensuring file changes are being detected. 
+     * @summary Get watch mode status
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getWatchStatus: async (a = {}) => {
+      const e = "/watch-mode/status", r = new URL(e, V);
+      let t;
+      c && (t = c.baseOptions);
+      const s = { method: "GET", ...t, ...a }, o = {};
+      O(r, {});
+      let l = t && t.headers ? t.headers : {};
+      return s.headers = { ...o, ...l, ...a.headers }, {
+        url: b(r),
+        options: s
+      };
+    },
+    /**
+     * Initiates file watching for the specified project. This enables real-time monitoring of file changes within the project directory, allowing for automatic reloading and updates during development. Only one project can be watched at a time. 
+     * @summary Start file watching
+     * @param {StartWatchRequest} startWatchRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    startWatching: async (a, e = {}) => {
+      d("startWatching", "startWatchRequest", a);
+      const r = "/watch-mode/start", t = new URL(r, V);
+      let s;
+      c && (s = c.baseOptions);
+      const o = { method: "POST", ...s, ...e }, n = {}, l = {};
+      n["Content-Type"] = "application/json", O(t, l);
+      let i = s && s.headers ? s.headers : {};
+      return o.headers = { ...n, ...i, ...e.headers }, o.data = A(a, o, c), {
+        url: b(t),
+        options: o
+      };
+    },
+    /**
+     * Stops the current file watching session. This disables real-time monitoring of file changes and releases system resources. Use this when development is complete or when switching to a different project. 
+     * @summary Stop file watching
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    stopWatching: async (a = {}) => {
+      const e = "/watch-mode/stop", r = new URL(e, V);
+      let t;
+      c && (t = c.baseOptions);
+      const s = { method: "POST", ...t, ...a }, o = {};
+      O(r, {});
+      let l = t && t.headers ? t.headers : {};
+      return s.headers = { ...o, ...l, ...a.headers }, {
+        url: b(r),
+        options: s
+      };
+    }
+  };
+}, R = function(c) {
+  const a = ie(c);
+  return {
+    /**
+     * Retrieves the current status of the file watching system. This includes whether watch mode is enabled, which project is being watched, and the path being monitored. Useful for monitoring the development workflow and ensuring file changes are being detected. 
+     * @summary Get watch mode status
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async getWatchStatus(e) {
+      const r = await a.getWatchStatus(e), t = c?.serverIndex ?? 0, s = P["WatchModeApi.getWatchStatus"]?.[t]?.url;
+      return (o, n) => g(r, u, m, c)(o, s || n);
+    },
+    /**
+     * Initiates file watching for the specified project. This enables real-time monitoring of file changes within the project directory, allowing for automatic reloading and updates during development. Only one project can be watched at a time. 
+     * @summary Start file watching
+     * @param {StartWatchRequest} startWatchRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async startWatching(e, r) {
+      const t = await a.startWatching(e, r), s = c?.serverIndex ?? 0, o = P["WatchModeApi.startWatching"]?.[s]?.url;
+      return (n, l) => g(t, u, m, c)(n, o || l);
+    },
+    /**
+     * Stops the current file watching session. This disables real-time monitoring of file changes and releases system resources. Use this when development is complete or when switching to a different project. 
+     * @summary Stop file watching
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async stopWatching(e) {
+      const r = await a.stopWatching(e), t = c?.serverIndex ?? 0, s = P["WatchModeApi.stopWatching"]?.[t]?.url;
+      return (o, n) => g(r, u, m, c)(o, s || n);
+    }
+  };
+}, Ue = function(c, a, e) {
+  const r = R(c);
+  return {
+    /**
+     * Retrieves the current status of the file watching system. This includes whether watch mode is enabled, which project is being watched, and the path being monitored. Useful for monitoring the development workflow and ensuring file changes are being detected. 
+     * @summary Get watch mode status
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getWatchStatus(t) {
+      return r.getWatchStatus(t).then((s) => s(e, a));
+    },
+    /**
+     * Initiates file watching for the specified project. This enables real-time monitoring of file changes within the project directory, allowing for automatic reloading and updates during development. Only one project can be watched at a time. 
+     * @summary Start file watching
+     * @param {StartWatchRequest} startWatchRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    startWatching(t, s) {
+      return r.startWatching(t, s).then((o) => o(e, a));
+    },
+    /**
+     * Stops the current file watching session. This disables real-time monitoring of file changes and releases system resources. Use this when development is complete or when switching to a different project. 
+     * @summary Stop file watching
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    stopWatching(t) {
+      return r.stopWatching(t).then((s) => s(e, a));
+    }
+  };
+};
+class pe extends j {
+  /**
+   * Retrieves the current status of the file watching system. This includes whether watch mode is enabled, which project is being watched, and the path being monitored. Useful for monitoring the development workflow and ensuring file changes are being detected. 
+   * @summary Get watch mode status
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof WatchModeApi
+   */
+  getWatchStatus(a) {
+    return R(this.configuration).getWatchStatus(a).then((e) => e(this.axios, this.basePath));
+  }
+  /**
+   * Initiates file watching for the specified project. This enables real-time monitoring of file changes within the project directory, allowing for automatic reloading and updates during development. Only one project can be watched at a time. 
+   * @summary Start file watching
+   * @param {StartWatchRequest} startWatchRequest 
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof WatchModeApi
+   */
+  startWatching(a, e) {
+    return R(this.configuration).startWatching(a, e).then((r) => r(this.axios, this.basePath));
+  }
+  /**
+   * Stops the current file watching session. This disables real-time monitoring of file changes and releases system resources. Use this when development is complete or when switching to a different project. 
+   * @summary Stop file watching
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   * @memberof WatchModeApi
+   */
+  stopWatching(a) {
+    return R(this.configuration).stopWatching(a).then((e) => e(this.axios, this.basePath));
+  }
+}
+class he {
+  /**
+   * parameter for apiKey security
+   * @param name security name
+   * @memberof Configuration
+   */
+  apiKey;
+  /**
+   * parameter for basic security
+   *
+   * @type {string}
+   * @memberof Configuration
+   */
+  username;
+  /**
+   * parameter for basic security
+   *
+   * @type {string}
+   * @memberof Configuration
+   */
+  password;
+  /**
+   * parameter for oauth2 security
+   * @param name security name
+   * @param scopes oauth2 scope
+   * @memberof Configuration
+   */
+  accessToken;
+  /**
+   * override base path
+   *
+   * @type {string}
+   * @memberof Configuration
+   */
+  basePath;
+  /**
+   * override server index
+   *
+   * @type {number}
+   * @memberof Configuration
+   */
+  serverIndex;
+  /**
+   * base options for axios calls
+   *
+   * @type {any}
+   * @memberof Configuration
+   */
+  baseOptions;
+  /**
+   * The FormData constructor that will be used to create multipart form data
+   * requests. You can inject this here so that execution environments that
+   * do not support the FormData class can still run the generated client.
+   *
+   * @type {new () => FormData}
+   */
+  formDataCtor;
+  constructor(a = {}) {
+    this.apiKey = a.apiKey, this.username = a.username, this.password = a.password, this.accessToken = a.accessToken, this.basePath = a.basePath, this.serverIndex = a.serverIndex, this.baseOptions = {
+      ...a.baseOptions,
+      headers: {
+        ...a.baseOptions?.headers
+      }
+    }, this.formDataCtor = a.formDataCtor;
+  }
+  /**
+   * Check if the given MIME is a JSON MIME.
+   * JSON MIME examples:
+   *   application/json
+   *   application/json; charset=UTF8
+   *   APPLICATION/JSON
+   *   application/vnd.company+json
+   * @param mime - MIME (Multipurpose Internet Mail Extensions)
+   * @return True if the given MIME is JSON, false otherwise.
+   */
+  isJsonMime(a) {
+    const e = new RegExp("^(application/json|[^;/ 	]+/[^;/ 	]+[+]json)[ 	]*(;.*)?$", "i");
+    return a !== null && (e.test(a) || a.toLowerCase() === "application/json-patch+json");
+  }
+}
+const F = H(void 0), de = (c, a) => {
+  const e = `${window.location.protocol}//${window.location.host}/api/v0`, r = u.create({
+    baseURL: c || e,
+    withCredentials: !0
+  });
+  r.interceptors.request.use(async (s) => {
+    const o = await a?.();
+    return s.headers.Authorization = o ? `Bearer ${o}` : "", s;
+  });
+  const t = new he({ basePath: e });
+  return {
+    queryResults: new ne(t, e, r),
+    models: new _(t, e, r),
+    projects: new re(t, e, r),
+    packages: new te(t, e, r),
+    notebooks: new Z(t, e, r),
+    connections: new z(t, e, r),
+    databases: new K(t, e, r),
+    schedules: new le(t, e, r),
+    watchMode: new pe(t, e, r)
+  };
+}, we = ({
+  children: c,
+  getAccessToken: a,
+  baseURL: e,
+  mutable: r = !0
+}) => {
+  const t = W(
+    () => de(e, a),
+    [e, a]
+  ), s = {
+    server: e || `${window.location.protocol}//${window.location.host}/api/v0`,
+    getAccessToken: a,
+    apiClients: t,
+    mutable: r
+  };
+  return /* @__PURE__ */ w(E, { client: f, children: /* @__PURE__ */ w(F.Provider, { value: s, children: c }) });
+}, Te = () => {
+  const c = L(F);
+  if (c === void 0)
+    throw new Error("useServer must be used within a ServerProvider");
+  return c;
+};
+export {
+  Q as A,
+  Re as B,
+  Oe as C,
+  ge as D,
+  ke as E,
+  q as F,
+  Ne as G,
+  ne as H,
+  ce as I,
+  B as J,
+  Ie as K,
+  le as L,
+  Y as M,
+  ye as N,
+  R as O,
+  ee as P,
+  oe as Q,
+  Ue as R,
+  we as S,
+  pe as T,
+  he as U,
+  ie as W,
+  be as a,
+  G as b,
+  S as c,
+  Se as d,
+  z as e,
+  J as f,
+  f as g,
+  T as h,
+  je as i,
+  K as j,
+  I as k,
+  Ae as l,
+  _ as m,
+  X as n,
+  U as o,
+  xe as p,
+  Z as q,
+  C as r,
+  Ce as s,
+  te as t,
+  Te as u,
+  ae as v,
+  v as w,
+  ve as x,
+  re as y,
+  se as z
+};