@mitralab.io/sdk-core 0.1.0 → 0.2.0-beta.0

package/dist/index.cjs

@@ -20,19 +20,46 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AgentTaskTurnError: () => AgentTaskTurnError,
   SdkCoreConfigurationError: () => SdkCoreConfigurationError,
   SdkCoreResponseError: () => SdkCoreResponseError,
+  createAgentConnectionsModule: () => createAgentConnectionsModule,
+  createAgentCredentialsModule: () => createAgentCredentialsModule,
+  createAgentTaskSessionManager: () => createAgentTaskSessionManager,
+  createAgentTasksModule: () => createAgentTasksModule,
+  createAgentsModule: () => createAgentsModule,
+  createAppsModule: () => createAppsModule,
   createAuthModule: () => createAuthModule,
+  createContextModule: () => createContextModule,
+  createCustomQueriesModule: () => createCustomQueriesModule,
+  createDataSourcesModule: () => createDataSourcesModule,
   createEntitiesModule: () => createEntitiesModule,
+  createFunctionsAdminModule: () => createFunctionsAdminModule,
   createFunctionsModule: () => createFunctionsModule,
+  createImportsModule: () => createImportsModule,
+  createIntegrationAdminModule: () => createIntegrationAdminModule,
   createIntegrationModule: () => createIntegrationModule,
+  createIntegrationResourcesModule: () => createIntegrationResourcesModule,
+  createIntegrationTemplatesModule: () => createIntegrationTemplatesModule,
+  createMembersModule: () => createMembersModule,
+  createMessengerModule: () => createMessengerModule,
+  createPublicFunctionsModule: () => createPublicFunctionsModule,
   createQueriesModule: () => createQueriesModule,
+  createSchemaModule: () => createSchemaModule,
   createSdkCore: () => createSdkCore,
+  createSqlModule: () => createSqlModule,
+  createWorkflowsModule: () => createWorkflowsModule,
   defaultSdkCoreErrorFactory: () => defaultSdkCoreErrorFactory,
   encodePathSegment: () => encodePathSegment,
   expectEmpty: () => expectEmpty,
+  expectLegacyPage: () => expectLegacyPage,
+  expectNullableObject: () => expectNullableObject,
   expectObject: () => expectObject,
-  expectObjectArray: () => expectObjectArray
+  expectObjectArray: () => expectObjectArray,
+  expectPage: () => expectPage,
+  expectStringArray: () => expectStringArray,
+  toAgentTimelineItem: () => toAgentTimelineItem,
+  withAgentTaskSessions: () => withAgentTaskSessions
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -62,6 +89,23 @@ function invalidResponse(message, errors = defaultSdkCoreErrorFactory) {
   throw errors.invalidResponse(message);
 }
 
+// src/batch.ts
+function requireBatchSize(items, name, maxSize, errors = defaultSdkCoreErrorFactory) {
+  if (items.length < 1 || items.length > maxSize) {
+    configurationError(`${name} must contain between 1 and ${maxSize} items`, errors);
+  }
+}
+
+// src/path.ts
+function encodePathSegment(value, name, errors = defaultSdkCoreErrorFactory) {
+  const segment = String(value);
+  if (!segment.trim()) configurationError(`${name} must not be empty`, errors);
+  if (segment === "." || segment === "..") {
+    configurationError(`${name} must not be a dot segment`, errors);
+  }
+  return encodeURIComponent(segment);
+}
+
 // src/response.ts
 function isObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -69,6 +113,9 @@ function isObject(value) {
 function isNullableString(value) {
   return value === null || typeof value === "string";
 }
+function isNullableBoolean(value) {
+  return value === null || typeof value === "boolean";
+}
 function isInteger(value) {
   return typeof value === "number" && Number.isInteger(value);
 }
@@ -78,8 +125,23 @@ function isNullableInteger(value) {
 function isStringRecord(value) {
   return isObject(value) && Object.values(value).every((item) => typeof item === "string");
 }
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(isJsonValue);
+  return isObject(value) && Object.values(value).every(isJsonValue);
+}
+function isJsonRecord(value) {
+  return isObject(value) && Object.values(value).every(isJsonValue);
+}
+function isOneOf(value, allowed) {
+  return typeof value === "string" && allowed.includes(value);
+}
 function hasOwn(value, property) {
-  return Object.prototype.hasOwnProperty.call(value, property);
+  return Object.hasOwn(value, property);
 }
 function invalidField(context, field, errors) {
   return invalidResponse(`${context} has an invalid ${field} field`, errors);
@@ -90,21 +152,67 @@ function expectObject(value, context, errors = defaultSdkCoreErrorFactory) {
   }
   return value;
 }
-function expectObjectArray(value, context, errors = defaultSdkCoreErrorFactory) {
+function expectObjectArray(value, context, errors = defaultSdkCoreErrorFactory, validateItem) {
   if (!Array.isArray(value) || value.some((item) => !isObject(item))) {
     return invalidResponse(`${context} must be a JSON array of objects`, errors);
   }
+  if (validateItem) {
+    value.forEach((item, position) => validateItem(item, `${context} item ${position}`, errors));
+  }
+  return value;
+}
+function expectNullableObject(value, context, errors = defaultSdkCoreErrorFactory) {
+  return value === null ? null : expectObject(value, context, errors);
+}
+function expectStringArray(value, context, errors = defaultSdkCoreErrorFactory) {
+  if (!isStringArray(value)) {
+    return invalidResponse(`${context} must be a JSON array of strings`, errors);
+  }
   return value;
 }
+function expectPage(value, context, errors = defaultSdkCoreErrorFactory, validateItem) {
+  const page = expectObject(value, context, errors);
+  if (!Array.isArray(page.content) || page.content.some((item) => !isObject(item))) {
+    invalidField(context, "content", errors);
+  }
+  const metadata = expectObject(page.page, `${context} page`, errors);
+  for (const field of ["size", "totalElements", "totalPages", "number"]) {
+    if (!isInteger(metadata[field])) invalidField(`${context} page`, field, errors);
+  }
+  if (metadata.totalElements < page.content.length) {
+    invalidField(`${context} page`, "totalElements", errors);
+  }
+  if (validateItem) {
+    page.content.forEach(
+      (item, position) => validateItem(item, `${context} item ${position}`, errors)
+    );
+  }
+  return page;
+}
+function expectLegacyPage(value, context, errors = defaultSdkCoreErrorFactory, validateItem) {
+  const page = expectObject(value, context, errors);
+  if (!Array.isArray(page.content) || page.content.some((item) => !isObject(item))) {
+    invalidField(context, "content", errors);
+  }
+  if (!isInteger(page.totalElements) || page.totalElements < page.content.length) {
+    invalidField(context, "totalElements", errors);
+  }
+  if (validateItem) {
+    page.content.forEach(
+      (item, position) => validateItem(item, `${context} item ${position}`, errors)
+    );
+  }
+  return page;
+}
 function expectTenant(value, context, errors = defaultSdkCoreErrorFactory) {
   const tenant = expectObject(value, context, errors);
   if (typeof tenant.id !== "string") invalidField(context, "id", errors);
   if (typeof tenant.shortId !== "string") invalidField(context, "shortId", errors);
   if (!isNullableInteger(tenant.legacyId)) invalidField(context, "legacyId", errors);
   if (typeof tenant.slug !== "string") invalidField(context, "slug", errors);
-  if (!isObject(tenant.plan)) invalidField(context, "plan", errors);
-  if (typeof tenant.plan.id !== "string") invalidField(`${context} plan`, "id", errors);
-  if (typeof tenant.plan.name !== "string") invalidField(`${context} plan`, "name", errors);
+  if (!isOneOf(tenant.clusterType, ["SHARED", "DEDICATED"])) {
+    invalidField(context, "clusterType", errors);
+  }
   if (typeof tenant.name !== "string") invalidField(context, "name", errors);
   if (!isNullableString(tenant.description)) invalidField(context, "description", errors);
   if (!isNullableString(tenant.hexColor)) invalidField(context, "hexColor", errors);
@@ -120,11 +228,29 @@ function expectUser(value, context, errors = defaultSdkCoreErrorFactory) {
   if (typeof user.name !== "string") invalidField(context, "name", errors);
   if (typeof user.email !== "string") invalidField(context, "email", errors);
   if (!isNullableString(user.imageUrl)) invalidField(context, "imageUrl", errors);
+  if (typeof user.planId !== "string") invalidField(context, "planId", errors);
   if (typeof user.onboardingCompleted !== "boolean") {
     invalidField(context, "onboardingCompleted", errors);
   }
+  if (typeof user.language !== "string") invalidField(context, "language", errors);
   return user;
 }
+function expectUserPlan(value, context, errors = defaultSdkCoreErrorFactory) {
+  const plan = expectObject(value, context, errors);
+  if (typeof plan.id !== "string") invalidField(context, "id", errors);
+  if (typeof plan.code !== "string") invalidField(context, "code", errors);
+  if (typeof plan.name !== "string") invalidField(context, "name", errors);
+  if (!isInteger(plan.maxUsers)) invalidField(context, "maxUsers", errors);
+  expectObjectArray(plan.prices, `${context} prices`, errors).forEach(
+    (price, position) => {
+      const priceContext = `${context} price ${position}`;
+      if (typeof price.currency !== "string") invalidField(priceContext, "currency", errors);
+      if (!isInteger(price.amountMinorUnits)) invalidField(priceContext, "amountMinorUnits", errors);
+      if (typeof price.interval !== "string") invalidField(priceContext, "interval", errors);
+    }
+  );
+  return plan;
+}
 function expectQueryResult(value, context, errors = defaultSdkCoreErrorFactory) {
   const result = expectObject(value, context, errors);
   if (!Array.isArray(result.rows) || result.rows.some((row) => !isObject(row))) {
@@ -159,7 +285,7 @@ function expectFunctionExecution(value, context, errors = defaultSdkCoreErrorFac
   if (!isNullableInteger(execution.durationMs)) invalidField(context, "durationMs", errors);
   if (!isNullableString(execution.startedAt)) invalidField(context, "startedAt", errors);
   if (!isNullableString(execution.finishedAt)) invalidField(context, "finishedAt", errors);
-  if (typeof execution.createdAt !== "string") invalidField(context, "createdAt", errors);
+  if (!isNullableString(execution.createdAt)) invalidField(context, "createdAt", errors);
   return execution;
 }
 function expectProxyResult(value, context, errors = defaultSdkCoreErrorFactory) {
@@ -175,194 +301,2062 @@ function expectProxyResult(value, context, errors = defaultSdkCoreErrorFactory)
   if (typeof result.executionId !== "string") invalidField(context, "executionId", errors);
   return result;
 }
-function expectEmpty(value, context, errors = defaultSdkCoreErrorFactory) {
-  if (value !== void 0) invalidResponse(`${context} must be empty`, errors);
+function expectBatchExecution(value, context, errors = defaultSdkCoreErrorFactory) {
+  const execution = expectObject(value, context, errors);
+  expectObjectArray(execution.results, `${context} results`, errors).forEach(
+    (item, position) => {
+      const itemContext = `${context} result ${position}`;
+      if (!isInteger(item.index)) invalidField(itemContext, "index", errors);
+      if (hasOwn(item, "affectedRows") && !isInteger(item.affectedRows)) {
+        invalidField(itemContext, "affectedRows", errors);
+      }
+      if (!isInteger(item.durationMs)) invalidField(itemContext, "durationMs", errors);
+    }
+  );
+  if (!isInteger(execution.executedCount)) invalidField(context, "executedCount", errors);
+  if (!isInteger(execution.totalDurationMs)) invalidField(context, "totalDurationMs", errors);
+  return execution;
 }
-
-// src/modules/auth.ts
-function createAuthModule(transport, errors = defaultSdkCoreErrorFactory) {
-  return {
-    async me() {
-      return expectUser(
-        await transport.request("/api/v1/auth/me", { method: "GET" }),
-        "Current user response",
-        errors
-      );
+function expectSchemaTables(value, context, errors = defaultSdkCoreErrorFactory) {
+  const groups = expectObjectArray(value, context, errors);
+  groups.forEach((group, position) => {
+    const groupContext = `${context} group ${position}`;
+    if (typeof group.schema !== "string") invalidField(groupContext, "schema", errors);
+    expectObjectArray(group.tables, `${groupContext} tables`, errors).forEach(
+      (table, tablePosition) => {
+        const tableContext = `${groupContext} table ${tablePosition}`;
+        if (typeof table.tableName !== "string") invalidField(tableContext, "tableName", errors);
+        expectObjectArray(table.columns, `${tableContext} columns`, errors).forEach(
+          (column, columnPosition) => {
+            const columnContext = `${tableContext} column ${columnPosition}`;
+            if (typeof column.name !== "string") invalidField(columnContext, "name", errors);
+            if (typeof column.type !== "string") invalidField(columnContext, "type", errors);
+            if (typeof column.primaryKey !== "boolean") {
+              invalidField(columnContext, "primaryKey", errors);
+            }
+            if (typeof column.nullable !== "boolean") {
+              invalidField(columnContext, "nullable", errors);
+            }
+            if (!isNullableString(column.defaultValue)) {
+              invalidField(columnContext, "defaultValue", errors);
+            }
+          }
+        );
+        expectObjectArray(
+          table.foreignKeys,
+          `${tableContext} foreignKeys`,
+          errors
+        ).forEach((foreignKey, foreignKeyPosition) => {
+          const foreignKeyContext = `${tableContext} foreign key ${foreignKeyPosition}`;
+          if (!isStringArray(foreignKey.columns)) {
+            invalidField(foreignKeyContext, "columns", errors);
+          }
+          if (typeof foreignKey.referencedTable !== "string") {
+            invalidField(foreignKeyContext, "referencedTable", errors);
+          }
+          if (!isStringArray(foreignKey.referencedColumns)) {
+            invalidField(foreignKeyContext, "referencedColumns", errors);
+          }
+        });
+      }
+    );
+  });
+  return groups;
+}
+function expectBulkResult(value, context, idField, errors) {
+  const result = expectObject(value, context, errors);
+  expectObjectArray(result.results, `${context} results`, errors).forEach(
+    (item, position) => {
+      const itemContext = `${context} result ${position}`;
+      if (!isInteger(item.index)) invalidField(itemContext, "index", errors);
+      if (typeof item.success !== "boolean") invalidField(itemContext, "success", errors);
+      if (hasOwn(item, idField) && !isNullableString(item[idField])) {
+        invalidField(itemContext, idField, errors);
+      }
+      if (hasOwn(item, "errorCode") && !isNullableString(item.errorCode)) {
+        invalidField(itemContext, "errorCode", errors);
+      }
+      if (hasOwn(item, "message") && !isNullableString(item.message)) {
+        invalidField(itemContext, "message", errors);
+      }
     }
-  };
+  );
+  if (!isInteger(result.processedCount)) invalidField(context, "processedCount", errors);
+  if (!isInteger(result.succeededCount)) invalidField(context, "succeededCount", errors);
+  if (!isInteger(result.failedCount)) invalidField(context, "failedCount", errors);
+  return result;
 }
-
-// src/path.ts
-function encodePathSegment(value, name, errors = defaultSdkCoreErrorFactory) {
-  const segment = String(value);
-  if (!segment.trim()) configurationError(`${name} must not be empty`, errors);
-  if (segment === "." || segment === "..") {
-    configurationError(`${name} must not be a dot segment`, errors);
+function expectTemplateConfigBulkResult(value, context, errors = defaultSdkCoreErrorFactory) {
+  return expectBulkResult(value, context, "configId", errors);
+}
+function expectFunctionVersion(value, context, errors) {
+  const version = expectObject(value, context, errors);
+  if (typeof version.id !== "string") invalidField(context, "id", errors);
+  if (typeof version.functionId !== "string") invalidField(context, "functionId", errors);
+  if (typeof version.status !== "string") invalidField(context, "status", errors);
+  if (typeof version.code !== "string") invalidField(context, "code", errors);
+  if (version.inputSchema !== null && !isObject(version.inputSchema)) {
+    invalidField(context, "inputSchema", errors);
   }
-  return encodeURIComponent(segment);
+  if (version.outputSchema !== null && !isObject(version.outputSchema)) {
+    invalidField(context, "outputSchema", errors);
+  }
+  if (version.secrets !== null && !isStringArray(version.secrets)) {
+    invalidField(context, "secrets", errors);
+  }
+  if (typeof version.createdAt !== "string") invalidField(context, "createdAt", errors);
 }
-
-// src/modules/entities.ts
-var DefaultEntitiesModule = class {
-  constructor(transport, errors) {
-    this.transport = transport;
-    this.errors = errors;
+function expectFunctionDefinition(value, context, errors = defaultSdkCoreErrorFactory) {
+  const definition = expectObject(value, context, errors);
+  if (typeof definition.id !== "string") invalidField(context, "id", errors);
+  if (typeof definition.tenantId !== "string") invalidField(context, "tenantId", errors);
+  if (!isNullableString(definition.appId)) invalidField(context, "appId", errors);
+  if (!isNullableInteger(definition.legacyId)) invalidField(context, "legacyId", errors);
+  if (typeof definition.name !== "string") invalidField(context, "name", errors);
+  if (!isNullableString(definition.description)) invalidField(context, "description", errors);
+  if (typeof definition.runtime !== "string") invalidField(context, "runtime", errors);
+  if (!isNullableString(definition.dataSourceId)) invalidField(context, "dataSourceId", errors);
+  if (typeof definition.visibility !== "string") invalidField(context, "visibility", errors);
+  if (definition.currentVersion !== null) {
+    expectFunctionVersion(definition.currentVersion, `${context} current version`, errors);
   }
-  tables = /* @__PURE__ */ new Map();
-  getTable(tableName) {
-    if (!this.tables.has(tableName)) {
-      this.tables.set(tableName, this.createTable(tableName));
+  if (!isNullableString(definition.cronExpression)) {
+    invalidField(context, "cronExpression", errors);
+  }
+  if (definition.cronInputJson !== null && !isJsonRecord(definition.cronInputJson)) {
+    invalidField(context, "cronInputJson", errors);
+  }
+  if (!isNullableBoolean(definition.cronEnabled)) invalidField(context, "cronEnabled", errors);
+  if (!isNullableString(definition.createdAt)) invalidField(context, "createdAt", errors);
+  if (typeof definition.updatedAt !== "string") invalidField(context, "updatedAt", errors);
+  return definition;
+}
+function expectFunctionDefinitions(value, context, errors = defaultSdkCoreErrorFactory) {
+  return expectObjectArray(value, context, errors).map(
+    (item, position) => expectFunctionDefinition(item, `${context} item ${position}`, errors)
+  );
+}
+function expectFunctionBulkDeleteResult(value, context, errors = defaultSdkCoreErrorFactory) {
+  const result = expectObject(value, context, errors);
+  if (!isStringArray(result.deleted)) invalidField(context, "deleted", errors);
+  if (!isStringArray(result.notFound)) invalidField(context, "notFound", errors);
+  if (!isInteger(result.deletedCount)) invalidField(context, "deletedCount", errors);
+  return result;
+}
+function expectTemplateConfigPage(value, context, errors = defaultSdkCoreErrorFactory) {
+  return expectLegacyPage(value, context, errors, expectTemplateConfigSummary);
+}
+function expectConnectionTestResult(value, context, errors = defaultSdkCoreErrorFactory) {
+  const result = expectObject(value, context, errors);
+  if (!isOneOf(result.status, ["unchecked", "connected", "error"])) {
+    invalidField(context, "status", errors);
+  }
+  if (!isInteger(result.durationMs)) invalidField(context, "durationMs", errors);
+  if (typeof result.checkedAt !== "string") invalidField(context, "checkedAt", errors);
+  if (!isNullableString(result.message)) invalidField(context, "message", errors);
+  return result;
+}
+function expectAppMembers(value, context, errors = defaultSdkCoreErrorFactory) {
+  const members = expectObjectArray(value, context, errors);
+  members.forEach((member, position) => {
+    const memberContext = `${context} member ${position}`;
+    if (typeof member.userId !== "string") invalidField(memberContext, "userId", errors);
+    if (typeof member.name !== "string") invalidField(memberContext, "name", errors);
+    if (typeof member.email !== "string") invalidField(memberContext, "email", errors);
+    if (typeof member.accessLevel !== "string") invalidField(memberContext, "accessLevel", errors);
+    if (typeof member.accessSource !== "string") {
+      invalidField(memberContext, "accessSource", errors);
     }
-    return this.tables.get(tableName);
+  });
+  return members;
+}
+function expectBulkUnsubscribeResult(value, context, errors = defaultSdkCoreErrorFactory) {
+  const result = expectObject(value, context, errors);
+  if (!isStringArray(result.revoked)) invalidField(context, "revoked", errors);
+  if (!isStringArray(result.notFound)) invalidField(context, "notFound", errors);
+  if (!isInteger(result.revokedCount)) invalidField(context, "revokedCount", errors);
+  return result;
+}
+function expectAppDefinition(value, context, errors = defaultSdkCoreErrorFactory) {
+  const app = expectObject(value, context, errors);
+  expectAppFields(app, context, errors);
+  if (!isNullableString(app.dataSourceId)) invalidField(context, "dataSourceId", errors);
+  return app;
+}
+function expectAppSummary(value, context, errors = defaultSdkCoreErrorFactory) {
+  const app = expectObject(value, context, errors);
+  expectAppFields(app, context, errors);
+  if (typeof app.tenantId !== "string") invalidField(context, "tenantId", errors);
+  return app;
+}
+function expectAppFields(app, context, errors) {
+  for (const field of ["id", "shortId", "subdomain", "brand", "name", "planId"]) {
+    if (typeof app[field] !== "string") invalidField(context, field, errors);
   }
-  createTable(tableName) {
-    const basePath = `/api/v1/tables/${encodePathSegment(tableName, "tableName", this.errors)}/records`;
-    return {
-      list: async (sortOrOptions, limit, skip, fields) => {
-        const options = typeof sortOrOptions === "object" ? sortOrOptions : void 0;
-        const params = {
-          sort: options?.sort ?? (typeof sortOrOptions === "string" ? sortOrOptions : void 0),
-          limit: options?.limit ?? limit,
-          skip: options?.skip ?? skip,
-          fields: (options?.fields ?? fields)?.join(",")
-        };
-        const response = expectObject(
-          await this.transport.request(basePath, { method: "GET", params }),
-          "Entity list response",
-          this.errors
-        );
-        return expectObjectArray(response.data, "Entity list data", this.errors);
-      },
-      filter: async (query, sort, limit, skip, fields) => {
-        const response = expectObject(
-          await this.transport.request(basePath, {
-            method: "GET",
-            params: {
-              q: JSON.stringify(query),
-              sort,
-              limit,
-              skip,
-              fields: fields?.join(",")
-            }
-          }),
-          "Entity list response",
-          this.errors
-        );
-        return expectObjectArray(response.data, "Entity list data", this.errors);
-      },
-      get: async (id) => expectObject(
-        await this.transport.request(
-          `${basePath}/${encodePathSegment(id, "id", this.errors)}`,
-          { method: "GET" }
-        ),
-        "Entity response",
-        this.errors
-      ),
-      create: async (data) => expectObject(
-        await this.transport.request(basePath, { method: "POST", body: data }),
-        "Created entity response",
-        this.errors
-      ),
-      bulkCreate: async (data) => expectObjectArray(
-        await this.transport.request(`${basePath}/bulk`, {
-          method: "POST",
-          body: data
-        }),
-        "Bulk create response",
-        this.errors
-      ),
-      update: async (id, data) => expectObject(
-        await this.transport.request(
-          `${basePath}/${encodePathSegment(id, "id", this.errors)}`,
-          { method: "PUT", body: data }
-        ),
-        "Updated entity response",
-        this.errors
-      ),
-      delete: (id) => this.transport.request(`${basePath}/${encodePathSegment(id, "id", this.errors)}`, {
-        method: "DELETE"
-      }).then((response) => expectEmpty(response, "Delete entity response", this.errors)),
-      deleteMany: async (query) => {
-        if (Object.keys(query).length === 0) {
-          configurationError("query must not be empty for deleteMany", this.errors);
-        }
-        const response = expectObject(
-          await this.transport.request(basePath, {
-            method: "DELETE",
-            params: { q: JSON.stringify(query) }
-          }),
-          "Delete many response",
-          this.errors
-        );
-        if (!Number.isInteger(response.deleted)) {
-          return invalidResponse(
-            "Delete many response must include an integer deleted count",
-            this.errors
-          );
-        }
-        return { deleted: response.deleted };
-      }
-    };
+  if (!isNullableInteger(app.legacyId)) invalidField(context, "legacyId", errors);
+  if (!isNullableString(app.description)) invalidField(context, "description", errors);
+  if (!isNullableString(app.icon)) invalidField(context, "icon", errors);
+  if (!isNullableString(app.template)) invalidField(context, "template", errors);
+  if (typeof app.allowSignup !== "boolean") invalidField(context, "allowSignup", errors);
+  if (typeof app.externalAccessEnabled !== "boolean") {
+    invalidField(context, "externalAccessEnabled", errors);
   }
-};
-function createEntitiesModule(transport, errors = defaultSdkCoreErrorFactory) {
-  const instance = new DefaultEntitiesModule(transport, errors);
-  return new Proxy(instance, {
-    get(target, property, receiver) {
-      if (typeof property !== "string" || property in target) {
-        return Reflect.get(target, property, receiver);
+  expectAppColor(app.color, `${context} color`, errors);
+  expectObjectArray(app.domains, `${context} domains`, errors).forEach(
+    (domain, position) => {
+      const domainContext = `${context} domain ${position}`;
+      if (typeof domain.hostname !== "string") invalidField(domainContext, "hostname", errors);
+      if (!isOneOf(domain.kind, ["PLATFORM", "CUSTOM"])) {
+        invalidField(domainContext, "kind", errors);
+      }
+      if (!isOneOf(domain.status, ["ACTIVE", "PENDING", "INACTIVE"])) {
+        invalidField(domainContext, "status", errors);
       }
-      return target.getTable(property);
     }
-  });
+  );
+  if (app.currentVersion !== null) {
+    expectAppVersion(app.currentVersion, `${context} currentVersion`, errors);
+  }
+  if (typeof app.createdAt !== "string") invalidField(context, "createdAt", errors);
+  if (typeof app.updatedAt !== "string") invalidField(context, "updatedAt", errors);
 }
-
-// src/modules/functions.ts
-var DefaultFunctionsModule = class {
-  constructor(transport, errors, options) {
-    this.transport = transport;
-    this.errors = errors;
-    this.options = options;
+function expectAppColor(value, context, errors) {
+  const color = expectObject(value, context, errors);
+  if (color.type === "SOLID") {
+    if (typeof color.hex !== "string") invalidField(context, "hex", errors);
+    return;
   }
-  execute(id, input) {
-    return this.executeWithType(id, this.options.executeInvocationType, input);
+  if (color.type === "GRADIENT") {
+    if (typeof color.startHex !== "string") invalidField(context, "startHex", errors);
+    if (typeof color.endHex !== "string") invalidField(context, "endHex", errors);
+    return;
   }
-  executeAsync(id, input) {
-    return this.executeWithType(id, "async", input);
+  invalidField(context, "type", errors);
+}
+function expectAppDeploy(value, context, errors = defaultSdkCoreErrorFactory) {
+  const deploy = expectObject(value, context, errors);
+  if (typeof deploy.id !== "string") invalidField(context, "id", errors);
+  if (typeof deploy.appId !== "string") invalidField(context, "appId", errors);
+  if (typeof deploy.appVersionId !== "string") invalidField(context, "appVersionId", errors);
+  if (!isOneOf(deploy.status, ["PENDING", "BUILDING", "DEPLOYED", "FAILED", "CANCELLED"])) {
+    invalidField(context, "status", errors);
   }
-  getExecution(id) {
-    return this.transport.request(
-      `/api/v1/executions/${encodePathSegment(id, "execution id", this.errors)}`,
-      { method: "GET" }
-    ).then(
-      (response) => expectFunctionExecution(response, "Function execution response", this.errors)
-    );
+  for (const field of ["deployUrl", "errorMessage", "logs", "startedAt", "finishedAt"]) {
+    if (!isNullableString(deploy[field])) invalidField(context, field, errors);
   }
-  cancelExecution(id) {
-    return this.transport.request(
-      `/api/v1/executions/${encodePathSegment(id, "execution id", this.errors)}/cancel`,
-      { method: "POST" }
-    ).then((response) => expectEmpty(response, "Cancel execution response", this.errors));
+  if (!isNullableInteger(deploy.durationMs)) invalidField(context, "durationMs", errors);
+  if (typeof deploy.createdAt !== "string") invalidField(context, "createdAt", errors);
+  return deploy;
+}
+function expectAppVersion(value, context, errors = defaultSdkCoreErrorFactory) {
+  const version = expectObject(value, context, errors);
+  if (typeof version.id !== "string") invalidField(context, "id", errors);
+  if (typeof version.appId !== "string") invalidField(context, "appId", errors);
+  if (!isOneOf(version.status, ["DRAFT", "PUBLISHED"])) {
+    invalidField(context, "status", errors);
   }
-  executeWithType(id, invocationType, input) {
-    const request = {
-      method: "POST",
-      ...input !== void 0 || this.options.emptyInput !== "omit-body" ? { body: { input: input ?? {} } } : {},
-      ...invocationType === void 0 ? {} : { headers: { "X-Invocation-Type": invocationType } }
-    };
-    return this.transport.request(
-      `/api/v1/functions/${encodePathSegment(id, "function id", this.errors)}/execute`,
-      request
-    ).then(
-      (response) => expectFunctionExecution(response, "Function execution response", this.errors)
-    );
+  if (version.currentDeploy !== null) {
+    expectAppDeploy(version.currentDeploy, `${context} currentDeploy`, errors);
   }
-};
-function createFunctionsModule(transport, options = {}, errors = defaultSdkCoreErrorFactory) {
-  return new DefaultFunctionsModule(transport, errors, options);
+  if (typeof version.createdAt !== "string") invalidField(context, "createdAt", errors);
+  return version;
 }
-
-// src/modules/integration.ts
+function expectCustomQueryDefinition(value, context, errors = defaultSdkCoreErrorFactory) {
+  const query = expectCustomQuerySummary(value, context, errors);
+  if (typeof query.sql !== "string") invalidField(context, "sql", errors);
+  return query;
+}
+function expectCustomQuerySummary(value, context, errors = defaultSdkCoreErrorFactory) {
+  const query = expectObject(value, context, errors);
+  if (typeof query.id !== "string") invalidField(context, "id", errors);
+  if (typeof query.name !== "string") invalidField(context, "name", errors);
+  if (typeof query.isVirtualTable !== "boolean") invalidField(context, "isVirtualTable", errors);
+  if (!isNullableString(query.connectionId)) invalidField(context, "connectionId", errors);
+  if (!isNullableString(query.createdAt)) invalidField(context, "createdAt", errors);
+  if (typeof query.updatedAt !== "string") invalidField(context, "updatedAt", errors);
+  return query;
+}
+function expectConnectionConfig(value, context, errors) {
+  const config = expectObject(value, context, errors);
+  for (const field of ["host", "schema", "databaseName", "username"]) {
+    if (!isNullableString(config[field])) invalidField(context, field, errors);
+  }
+  if (!isNullableInteger(config.port)) invalidField(context, "port", errors);
+  for (const field of [
+    "maxPoolSize",
+    "connectionTimeoutMs",
+    "idleTimeoutMs",
+    "minimumIdle",
+    "maxLifetimeMs"
+  ]) {
+    if (!isNullableInteger(config[field])) invalidField(context, field, errors);
+  }
+  if (config.additionalParams !== null && !isStringRecord(config.additionalParams)) {
+    invalidField(context, "additionalParams", errors);
+  }
+  if (config.credential !== null) invalidField(context, "credential", errors);
+}
+function expectDataSourceDefinition(value, context, errors = defaultSdkCoreErrorFactory) {
+  const dataSource = expectObject(value, context, errors);
+  if (typeof dataSource.id !== "string") invalidField(context, "id", errors);
+  if (!isNullableInteger(dataSource.legacyId)) invalidField(context, "legacyId", errors);
+  if (!isNullableString(dataSource.appId)) invalidField(context, "appId", errors);
+  if (typeof dataSource.name !== "string") invalidField(context, "name", errors);
+  if (!isOneOf(dataSource.instanceType, ["MITRA_SHARED", "MITRA_DEDICATED", "EXTERNAL"])) {
+    invalidField(context, "instanceType", errors);
+  }
+  if (!isOneOf(dataSource.dbType, ["POSTGRES", "MYSQL", "SQLSERVER", "ORACLE"])) {
+    invalidField(context, "dbType", errors);
+  }
+  expectConnectionConfig(
+    dataSource.writeConnectionConfig,
+    `${context} writeConnectionConfig`,
+    errors
+  );
+  if (dataSource.readConnectionConfig !== null) {
+    expectConnectionConfig(
+      dataSource.readConnectionConfig,
+      `${context} readConnectionConfig`,
+      errors
+    );
+  }
+  if (dataSource.connectionStatus !== null && !isOneOf(dataSource.connectionStatus, ["CONNECTED", "ERROR"])) {
+    invalidField(context, "connectionStatus", errors);
+  }
+  if (!isNullableString(dataSource.lastCheckedAt)) invalidField(context, "lastCheckedAt", errors);
+  if (dataSource.storageQuota !== null) {
+    const quota = expectObject(
+      dataSource.storageQuota,
+      `${context} storageQuota`,
+      errors
+    );
+    if (quota.status !== null && !isOneOf(quota.status, ["NORMAL", "WATCH", "BLOCKED"])) {
+      invalidField(`${context} storageQuota`, "status", errors);
+    }
+    for (const field of ["usedBytes", "limitBytes", "measurementVersion"]) {
+      if (!isNullableInteger(quota[field])) invalidField(`${context} storageQuota`, field, errors);
+    }
+    if (!isNullableString(quota.measuredAt)) {
+      invalidField(`${context} storageQuota`, "measuredAt", errors);
+    }
+  }
+  return dataSource;
+}
+function expectImportSource(value, context, errors) {
+  const source = expectObject(value, context, errors);
+  if (source.type === "SQL") {
+    if (typeof source.query !== "string") invalidField(context, "query", errors);
+    return;
+  }
+  if (source.type === "CSV") {
+    if (typeof source.fileKey !== "string") invalidField(context, "fileKey", errors);
+    if (typeof source.separator !== "string") invalidField(context, "separator", errors);
+    return;
+  }
+  invalidField(context, "type", errors);
+}
+function expectImportDefinition(value, context, errors = defaultSdkCoreErrorFactory) {
+  const definition = expectObject(value, context, errors);
+  if (typeof definition.id !== "string") invalidField(context, "id", errors);
+  if (!isNullableInteger(definition.legacyId)) invalidField(context, "legacyId", errors);
+  if (typeof definition.name !== "string") invalidField(context, "name", errors);
+  expectImportSource(definition.source, `${context} source`, errors);
+  const target = expectObject(definition.target, `${context} target`, errors);
+  if (typeof target.tableName !== "string") invalidField(`${context} target`, "tableName", errors);
+  if (!isOneOf(target.mode, ["REPLACE", "APPEND", "UPSERT"])) {
+    invalidField(`${context} target`, "mode", errors);
+  }
+  if (target.upsertKeyColumns !== null && !isStringArray(target.upsertKeyColumns)) {
+    invalidField(`${context} target`, "upsertKeyColumns", errors);
+  }
+  const processing = expectObject(
+    definition.processing,
+    `${context} processing`,
+    errors
+  );
+  if (!isOneOf(processing.mode, ["CHUNKED", "STREAMING"])) {
+    invalidField(`${context} processing`, "mode", errors);
+  }
+  if (!isNullableString(processing.orderColumn)) {
+    invalidField(`${context} processing`, "orderColumn", errors);
+  }
+  if (!isInteger(processing.chunkSize)) invalidField(`${context} processing`, "chunkSize", errors);
+  const schedule = expectObject(definition.schedule, `${context} schedule`, errors);
+  if (!isNullableString(schedule.cron)) invalidField(`${context} schedule`, "cron", errors);
+  if (typeof schedule.enabled !== "boolean") invalidField(`${context} schedule`, "enabled", errors);
+  if (definition.columnMappings !== null) {
+    expectObjectArray(
+      definition.columnMappings,
+      `${context} columnMappings`,
+      errors
+    ).forEach((mapping, position) => {
+      const mappingContext = `${context} columnMapping ${position}`;
+      if (typeof mapping.source !== "string") invalidField(mappingContext, "source", errors);
+      if (typeof mapping.target !== "string") invalidField(mappingContext, "target", errors);
+      if (hasOwn(mapping, "type") && !isNullableString(mapping.type)) {
+        invalidField(mappingContext, "type", errors);
+      }
+    });
+  }
+  if (typeof definition.createdAt !== "string") invalidField(context, "createdAt", errors);
+  if (typeof definition.updatedAt !== "string") invalidField(context, "updatedAt", errors);
+  return definition;
+}
+function expectImportExecution(value, context, errors = defaultSdkCoreErrorFactory) {
+  const execution = expectObject(value, context, errors);
+  if (typeof execution.id !== "string") invalidField(context, "id", errors);
+  if (typeof execution.importDefinitionId !== "string") {
+    invalidField(context, "importDefinitionId", errors);
+  }
+  if (!isNullableString(execution.importName)) invalidField(context, "importName", errors);
+  if (!isOneOf(execution.status, [
+    "PENDING",
+    "PREPARING",
+    "RUNNING",
+    "COMPLETED",
+    "PARTIALLY_COMPLETED",
+    "FAILED",
+    "CANCELLED"
+  ])) {
+    invalidField(context, "status", errors);
+  }
+  if (!isOneOf(execution.triggerType, ["MANUAL", "SCHEDULED", "API"])) {
+    invalidField(context, "triggerType", errors);
+  }
+  for (const field of ["totalChunks", "progressPercent", "rowsTotal", "durationSeconds"]) {
+    if (!isNullableInteger(execution[field])) invalidField(context, field, errors);
+  }
+  for (const field of ["completedChunks", "failedChunks", "rowsProcessed"]) {
+    if (!isInteger(execution[field])) invalidField(context, field, errors);
+  }
+  if (typeof execution.queuedAt !== "string") invalidField(context, "queuedAt", errors);
+  if (!isNullableString(execution.startedAt)) invalidField(context, "startedAt", errors);
+  if (!isNullableString(execution.completedAt)) invalidField(context, "completedAt", errors);
+  if (!isNullableString(execution.errorMessage)) invalidField(context, "errorMessage", errors);
+  return execution;
+}
+function expectMessageAccepted(value, context, errors = defaultSdkCoreErrorFactory) {
+  const response = expectObject(value, context, errors);
+  if (typeof response.messageId !== "string") invalidField(context, "messageId", errors);
+  return response;
+}
+function expectAgentDefinition(value, context, errors = defaultSdkCoreErrorFactory) {
+  const agent = expectObject(value, context, errors);
+  if (typeof agent.id !== "string") invalidField(context, "id", errors);
+  if (typeof agent.name !== "string") invalidField(context, "name", errors);
+  if (!isStringArray(agent.functionIds)) invalidField(context, "functionIds", errors);
+  if (typeof agent.autonomous !== "boolean") invalidField(context, "autonomous", errors);
+  if (typeof agent.createdAt !== "string") invalidField(context, "createdAt", errors);
+  if (typeof agent.updatedAt !== "string") invalidField(context, "updatedAt", errors);
+  return agent;
+}
+function expectAgentBulkDeleteResult(value, context, errors = defaultSdkCoreErrorFactory) {
+  const result = expectObject(value, context, errors);
+  if (!isStringArray(result.deleted)) invalidField(context, "deleted", errors);
+  if (!isStringArray(result.notFound)) invalidField(context, "notFound", errors);
+  if (!isInteger(result.deletedCount)) invalidField(context, "deletedCount", errors);
+  return result;
+}
+function expectWorkflowDefinition(value, context, errors = defaultSdkCoreErrorFactory) {
+  const workflow = expectWorkflowSummary(value, context, errors);
+  if (!isObject(workflow.definition)) invalidField(context, "definition", errors);
+  return workflow;
+}
+function expectWorkflowSummary(value, context, errors = defaultSdkCoreErrorFactory) {
+  const workflow = expectObject(value, context, errors);
+  if (typeof workflow.id !== "string") invalidField(context, "id", errors);
+  if (typeof workflow.tenantId !== "string") invalidField(context, "tenantId", errors);
+  if (!isNullableString(workflow.appId)) invalidField(context, "appId", errors);
+  if (typeof workflow.name !== "string") invalidField(context, "name", errors);
+  if (typeof workflow.createdAt !== "string") invalidField(context, "createdAt", errors);
+  if (typeof workflow.updatedAt !== "string") invalidField(context, "updatedAt", errors);
+  return workflow;
+}
+function expectWorkflowExecution(value, context, errors = defaultSdkCoreErrorFactory) {
+  const execution = expectObject(value, context, errors);
+  if (typeof execution.id !== "string") invalidField(context, "id", errors);
+  if (typeof execution.tenantId !== "string") invalidField(context, "tenantId", errors);
+  if (!isNullableString(execution.appId)) invalidField(context, "appId", errors);
+  if (typeof execution.workflowId !== "string") invalidField(context, "workflowId", errors);
+  if (!isOneOf(execution.triggerType, ["MANUAL", "SCHEDULED"])) {
+    invalidField(context, "triggerType", errors);
+  }
+  if (!isNullableString(execution.triggeredBy)) invalidField(context, "triggeredBy", errors);
+  if (!isOneOf(execution.status, ["PENDING", "RUNNING", "SUCCESS", "FAILED", "CANCELLED"])) {
+    invalidField(context, "status", errors);
+  }
+  if (!isNullableString(execution.currentStepId)) invalidField(context, "currentStepId", errors);
+  if (execution.context !== null && !isJsonRecord(execution.context)) {
+    invalidField(context, "context", errors);
+  }
+  if (!isNullableString(execution.errorMessage)) invalidField(context, "errorMessage", errors);
+  if (!isNullableString(execution.startedAt)) invalidField(context, "startedAt", errors);
+  if (!isNullableString(execution.finishedAt)) invalidField(context, "finishedAt", errors);
+  if (typeof execution.createdAt !== "string") invalidField(context, "createdAt", errors);
+  return execution;
+}
+function expectIntegrationResource(value, context, errors = defaultSdkCoreErrorFactory) {
+  const resource = expectObject(value, context, errors);
+  if (typeof resource.id !== "string") invalidField(context, "id", errors);
+  if (typeof resource.tenantId !== "string") invalidField(context, "tenantId", errors);
+  if (typeof resource.templateConfigId !== "string")
+    invalidField(context, "templateConfigId", errors);
+  if (typeof resource.name !== "string") invalidField(context, "name", errors);
+  if (typeof resource.method !== "string") invalidField(context, "method", errors);
+  if (typeof resource.endpoint !== "string") invalidField(context, "endpoint", errors);
+  if (resource.body !== null && !isJsonRecord(resource.body)) {
+    invalidField(context, "body", errors);
+  }
+  const params = expectObject(resource.params, `${context} params`, errors);
+  Object.entries(params).forEach(([name, value2]) => {
+    const paramContext = `${context} param ${name}`;
+    const param = expectObject(value2, paramContext, errors);
+    if (typeof param.type !== "string") invalidField(paramContext, "type", errors);
+    if (typeof param.required !== "boolean") invalidField(paramContext, "required", errors);
+    if (!isJsonValue(param.defaultValue)) invalidField(paramContext, "defaultValue", errors);
+    if (!isNullableString(param.description)) invalidField(paramContext, "description", errors);
+  });
+  if (typeof resource.createdAt !== "string") invalidField(context, "createdAt", errors);
+  if (typeof resource.updatedAt !== "string") invalidField(context, "updatedAt", errors);
+  return resource;
+}
+function expectIntegrationResourceSummary(value, context, errors = defaultSdkCoreErrorFactory) {
+  const resource = expectObject(value, context, errors);
+  if (typeof resource.id !== "string") invalidField(context, "id", errors);
+  if (typeof resource.name !== "string") invalidField(context, "name", errors);
+  if (typeof resource.method !== "string") invalidField(context, "method", errors);
+  if (typeof resource.endpoint !== "string") invalidField(context, "endpoint", errors);
+  return resource;
+}
+function expectIntegrationTemplateSummary(value, context, errors = defaultSdkCoreErrorFactory) {
+  const template = expectObject(value, context, errors);
+  if (typeof template.id !== "string") invalidField(context, "id", errors);
+  if (typeof template.name !== "string") invalidField(context, "name", errors);
+  if (!isNullableString(template.baseUrl)) invalidField(context, "baseUrl", errors);
+  if (!isOneOf(template.proxyMode, ["OPEN", "RESOURCE_ONLY"])) {
+    invalidField(context, "proxyMode", errors);
+  }
+  if (!isNullableString(template.logoUrl)) invalidField(context, "logoUrl", errors);
+  if (!isOneOf(template.templateType, ["GENERIC_AUTH", "PROVIDER"])) {
+    invalidField(context, "templateType", errors);
+  }
+  return template;
+}
+function expectIntegrationTemplate(value, context, errors = defaultSdkCoreErrorFactory) {
+  const template = expectIntegrationTemplateSummary(value, context, errors);
+  if (template.loginConfig !== null) {
+    expectIntegrationLoginConfig(template.loginConfig, `${context} loginConfig`, errors);
+  }
+  expectIntegrationRequestConfig(template.requestConfig, `${context} requestConfig`, errors);
+  expectObjectArray(template.fieldsSchema, `${context} fieldsSchema`, errors).forEach(
+    (field, position) => {
+      const fieldContext = `${context} field ${position}`;
+      if (typeof field.key !== "string") invalidField(fieldContext, "key", errors);
+      if (typeof field.label !== "string") invalidField(fieldContext, "label", errors);
+      if (!isOneOf(field.type, ["url", "text", "secret"])) {
+        invalidField(fieldContext, "type", errors);
+      }
+      if (typeof field.required !== "boolean") invalidField(fieldContext, "required", errors);
+      if (!isNullableString(field.placeholder)) invalidField(fieldContext, "placeholder", errors);
+      if (!isNullableString(field.default)) invalidField(fieldContext, "default", errors);
+    }
+  );
+  if (!isNullableString(template.documentationUrl)) {
+    invalidField(context, "documentationUrl", errors);
+  }
+  return template;
+}
+function expectIntegrationLoginConfig(value, context, errors) {
+  const config = expectObject(value, context, errors);
+  if (!isNullableString(config.url)) invalidField(context, "url", errors);
+  if (!isNullableString(config.method)) invalidField(context, "method", errors);
+  for (const field of ["headers", "query_params", "body_form", "body"]) {
+    if (config[field] !== null && !isJsonRecord(config[field])) {
+      invalidField(context, field, errors);
+    }
+  }
+  if (config.token_extraction !== null) {
+    const extraction = expectObject(
+      config.token_extraction,
+      `${context} token_extraction`,
+      errors
+    );
+    for (const field of ["source", "path", "name"]) {
+      if (!isNullableString(extraction[field])) {
+        invalidField(`${context} token_extraction`, field, errors);
+      }
+    }
+  }
+  if (!isNullableInteger(config.token_ttl_seconds)) {
+    invalidField(context, "token_ttl_seconds", errors);
+  }
+}
+function expectIntegrationRequestConfig(value, context, errors) {
+  const config = expectObject(value, context, errors);
+  if (config.headers !== null && !isJsonRecord(config.headers)) {
+    invalidField(context, "headers", errors);
+  }
+  if (config.credential_rules !== null) {
+    expectObjectArray(
+      config.credential_rules,
+      `${context} credential_rules`,
+      errors
+    ).forEach((rule, position) => {
+      const ruleContext = `${context} credential rule ${position}`;
+      if (rule.placement !== null && !isOneOf(rule.placement, ["HEADER", "QUERY", "COOKIE", "BODY", "BASIC"])) {
+        invalidField(ruleContext, "placement", errors);
+      }
+      for (const field of ["name", "path", "value"]) {
+        if (!isNullableString(rule[field])) invalidField(ruleContext, field, errors);
+      }
+    });
+  }
+}
+function expectTemplateConfigSummary(value, context, errors = defaultSdkCoreErrorFactory) {
+  const config = expectObject(value, context, errors);
+  if (typeof config.id !== "string") invalidField(context, "id", errors);
+  if (!isNullableString(config.appId)) invalidField(context, "appId", errors);
+  if (!isNullableInteger(config.legacyId)) invalidField(context, "legacyId", errors);
+  if (typeof config.templateId !== "string") invalidField(context, "templateId", errors);
+  if (typeof config.alias !== "string") invalidField(context, "alias", errors);
+  if (config.status !== null && !isOneOf(config.status, ["unchecked", "connected", "error"])) {
+    invalidField(context, "status", errors);
+  }
+  if (!isNullableString(config.lastCheckedAt)) invalidField(context, "lastCheckedAt", errors);
+  return config;
+}
+function expectTemplateConfig(value, context, errors = defaultSdkCoreErrorFactory) {
+  const config = expectTemplateConfigSummary(value, context, errors);
+  if (typeof config.tenantId !== "string") invalidField(context, "tenantId", errors);
+  if (!isJsonRecord(config.config)) invalidField(context, "config", errors);
+  if (!isNullableString(config.lastCheckMessage)) {
+    invalidField(context, "lastCheckMessage", errors);
+  }
+  if (typeof config.createdAt !== "string") invalidField(context, "createdAt", errors);
+  if (typeof config.updatedAt !== "string") invalidField(context, "updatedAt", errors);
+  return config;
+}
+function expectIntegrationExecution(value, context, errors = defaultSdkCoreErrorFactory) {
+  const execution = expectObject(value, context, errors);
+  if (typeof execution.id !== "string") invalidField(context, "id", errors);
+  if (typeof execution.templateConfigId !== "string") {
+    invalidField(context, "templateConfigId", errors);
+  }
+  if (!isNullableString(execution.appId)) invalidField(context, "appId", errors);
+  if (typeof execution.method !== "string") invalidField(context, "method", errors);
+  if (typeof execution.endpoint !== "string") invalidField(context, "endpoint", errors);
+  if (!hasOwn(execution, "requestBody") || !isJsonValue(execution.requestBody)) {
+    invalidField(context, "requestBody", errors);
+  }
+  if (!isNullableInteger(execution.responseStatus)) {
+    invalidField(context, "responseStatus", errors);
+  }
+  if (!hasOwn(execution, "responseBody") || !isJsonValue(execution.responseBody)) {
+    invalidField(context, "responseBody", errors);
+  }
+  if (!isNullableInteger(execution.durationMs)) invalidField(context, "durationMs", errors);
+  if (typeof execution.success !== "boolean") invalidField(context, "success", errors);
+  if (!isNullableString(execution.errorMessage)) invalidField(context, "errorMessage", errors);
+  if (!isNullableString(execution.source)) invalidField(context, "source", errors);
+  if (typeof execution.createdAt !== "string") invalidField(context, "createdAt", errors);
+  return execution;
+}
+function expectAgentTask(value, context, errors = defaultSdkCoreErrorFactory) {
+  const task = expectObject(value, context, errors);
+  if (typeof task.id !== "string") invalidField(context, "id", errors);
+  for (const field of ["appId", "agentId", "userId", "title", "reasoningEffort"]) {
+    if (!isNullableString(task[field])) invalidField(context, field, errors);
+  }
+  if (typeof task.agentType !== "string") invalidField(context, "agentType", errors);
+  if (typeof task.archived !== "boolean") invalidField(context, "archived", errors);
+  if (!isNullableString(task.createdAt)) invalidField(context, "createdAt", errors);
+  if (typeof task.updatedAt !== "string") invalidField(context, "updatedAt", errors);
+  return task;
+}
+function expectAgentMessage(value, context, errors = defaultSdkCoreErrorFactory) {
+  const message = expectObject(value, context, errors);
+  for (const field of ["id", "sender", "type", "content", "createdAt"]) {
+    if (typeof message[field] !== "string") invalidField(context, field, errors);
+  }
+  return message;
+}
+function expectAgentModel(value, context, errors = defaultSdkCoreErrorFactory) {
+  const model = expectObject(value, context, errors);
+  for (const field of ["model", "name", "provider", "agentType"]) {
+    if (typeof model[field] !== "string") invalidField(context, field, errors);
+  }
+  if (!isStringArray(model.reasoningOptions)) invalidField(context, "reasoningOptions", errors);
+  return model;
+}
+function expectCredentialStatus(value, context, errors = defaultSdkCoreErrorFactory) {
+  const status = expectObject(value, context, errors);
+  if (typeof status.provider !== "string") invalidField(context, "provider", errors);
+  if (typeof status.connected !== "boolean") invalidField(context, "connected", errors);
+  for (const field of ["credentialType", "accountEmail", "maskedApiKey"]) {
+    if (!isNullableString(status[field])) invalidField(context, field, errors);
+  }
+  return status;
+}
+function expectOAuthStartResult(value, context, errors = defaultSdkCoreErrorFactory) {
+  const result = expectObject(value, context, errors);
+  if (typeof result.authUrl !== "string") invalidField(context, "authUrl", errors);
+  if (typeof result.state !== "string") invalidField(context, "state", errors);
+  return result;
+}
+function expectAuthenticationResult(value, context, errors = defaultSdkCoreErrorFactory) {
+  const result = expectObject(value, context, errors);
+  if (typeof result.connected !== "boolean") invalidField(context, "connected", errors);
+  if (!isNullableString(result.email)) invalidField(context, "email", errors);
+  return result;
+}
+function expectDeviceAuthorization(value, context, errors = defaultSdkCoreErrorFactory) {
+  const result = expectObject(value, context, errors);
+  for (const field of ["deviceAuthId", "userCode", "verificationUri"]) {
+    if (typeof result[field] !== "string") invalidField(context, field, errors);
+  }
+  if (!isInteger(result.intervalSeconds)) invalidField(context, "intervalSeconds", errors);
+  return result;
+}
+function expectProviderCredentialStatus(value, context, errors) {
+  const status = expectObject(value, context, errors);
+  if (typeof status.provider !== "string") invalidField(context, "provider", errors);
+  if (typeof status.connected !== "boolean") invalidField(context, "connected", errors);
+  if (!isNullableString(status.credentialType)) invalidField(context, "credentialType", errors);
+  if (!isNullableString(status.accountEmail)) invalidField(context, "accountEmail", errors);
+  return status;
+}
+function expectAgentConnection(value, context, errors = defaultSdkCoreErrorFactory) {
+  const connection = expectObject(value, context, errors);
+  if (typeof connection.id !== "string") invalidField(context, "id", errors);
+  if (typeof connection.name !== "string") invalidField(context, "name", errors);
+  if (typeof connection.createdAt !== "string") invalidField(context, "createdAt", errors);
+  if (typeof connection.updatedAt !== "string") invalidField(context, "updatedAt", errors);
+  expectObjectArray(
+    connection.credentials,
+    `${context} credentials`,
+    errors,
+    expectProviderCredentialStatus
+  );
+  return connection;
+}
+function expectTableDefinition(value, context, errors = defaultSdkCoreErrorFactory) {
+  const wrapped = expectSchemaTables([{ schema: "validation", tables: [value] }], context, errors);
+  return wrapped[0].tables[0];
+}
+function expectFunctionSummary(value, context, errors = defaultSdkCoreErrorFactory) {
+  const summary = expectObject(value, context, errors);
+  if (typeof summary.id !== "string") invalidField(context, "id", errors);
+  if (typeof summary.tenantId !== "string") invalidField(context, "tenantId", errors);
+  if (!isNullableString(summary.appId)) invalidField(context, "appId", errors);
+  if (!isNullableInteger(summary.legacyId)) invalidField(context, "legacyId", errors);
+  if (typeof summary.name !== "string") invalidField(context, "name", errors);
+  if (!isNullableString(summary.description)) invalidField(context, "description", errors);
+  if (typeof summary.runtime !== "string") invalidField(context, "runtime", errors);
+  if (!isNullableString(summary.dataSourceId)) invalidField(context, "dataSourceId", errors);
+  if (typeof summary.visibility !== "string") invalidField(context, "visibility", errors);
+  if (!isNullableString(summary.cronExpression)) invalidField(context, "cronExpression", errors);
+  if (summary.cronInputJson !== null && !isJsonRecord(summary.cronInputJson)) {
+    invalidField(context, "cronInputJson", errors);
+  }
+  if (!isNullableBoolean(summary.cronEnabled)) invalidField(context, "cronEnabled", errors);
+  if (typeof summary.createdAt !== "string") invalidField(context, "createdAt", errors);
+  if (typeof summary.updatedAt !== "string") invalidField(context, "updatedAt", errors);
+  return summary;
+}
+function expectFunctionVersionResponse(value, context, errors = defaultSdkCoreErrorFactory) {
+  expectFunctionVersion(value, context, errors);
+  return value;
+}
+function expectFunctionSecrets(value, context, errors = defaultSdkCoreErrorFactory) {
+  const result = expectObject(value, context, errors);
+  if (!isStringArray(result.secrets)) invalidField(context, "secrets", errors);
+  return result;
+}
+function expectPublicFunctionResult(value, context, errors = defaultSdkCoreErrorFactory) {
+  const result = expectObject(value, context, errors);
+  if (typeof result.success !== "boolean") invalidField(context, "success", errors);
+  if (result.output !== null && !isObject(result.output)) invalidField(context, "output", errors);
+  if (!isNullableString(result.error)) invalidField(context, "error", errors);
+  return result;
+}
+function expectPublicFunctionAsyncResult(value, context, errors = defaultSdkCoreErrorFactory) {
+  const result = expectObject(value, context, errors);
+  if (typeof result.id !== "string") invalidField(context, "id", errors);
+  if (typeof result.status !== "string") invalidField(context, "status", errors);
+  return result;
+}
+function expectEmpty(value, context, errors = defaultSdkCoreErrorFactory) {
+  if (value !== void 0) invalidResponse(`${context} must be empty`, errors);
+}
+
+// src/modules/agentConnections.ts
+var MAX_CONNECTIONS = 100;
+function createAgentConnectionsModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const path = (id) => `/api/v1/connections/${encodePathSegment(id, "connection id", errors)}`;
+  const providerPath = (id, provider) => `${path(id)}/providers/${encodePathSegment(provider, "provider", errors)}`;
+  return {
+    async list() {
+      return expectObjectArray(
+        await transport.request("/api/v1/connections", { method: "GET" }),
+        "Connection response",
+        errors,
+        expectAgentConnection
+      );
+    },
+    async get(id) {
+      return expectAgentConnection(
+        await transport.request(path(id), { method: "GET" }),
+        "Connection response",
+        errors
+      );
+    },
+    async create(name) {
+      return expectAgentConnection(
+        await transport.request("/api/v1/connections", {
+          method: "POST",
+          body: { name }
+        }),
+        "Create connection response",
+        errors
+      );
+    },
+    async bulkCreate(inputs) {
+      requireBatchSize(inputs, "connections", MAX_CONNECTIONS, errors);
+      return expectObjectArray(
+        await transport.request("/api/v1/connections/bulk", {
+          method: "POST",
+          body: { connections: inputs }
+        }),
+        "Bulk create connections response",
+        errors,
+        expectAgentConnection
+      );
+    },
+    async delete(id) {
+      expectEmpty(
+        await transport.request(path(id), { method: "DELETE" }),
+        "Delete connection response",
+        errors
+      );
+    },
+    async saveApiKey(id, provider, apiKey) {
+      expectEmpty(
+        await transport.request(`${providerPath(id, provider)}/api-key`, {
+          method: "PUT",
+          body: { apiKey }
+        }),
+        "Save connection API key response",
+        errors
+      );
+    },
+    async disconnectProvider(id, provider) {
+      expectEmpty(
+        await transport.request(providerPath(id, provider), { method: "DELETE" }),
+        "Disconnect connection provider response",
+        errors
+      );
+    },
+    async startOAuth(id, provider) {
+      return expectOAuthStartResult(
+        await transport.request(`${providerPath(id, provider)}/oauth/start`, {
+          method: "POST"
+        }),
+        "Connection OAuth start response",
+        errors
+      );
+    },
+    async exchangeOAuth(id, provider, input) {
+      return expectAuthenticationResult(
+        await transport.request(`${providerPath(id, provider)}/oauth/exchange`, {
+          method: "POST",
+          body: input
+        }),
+        "Connection OAuth exchange response",
+        errors
+      );
+    },
+    async startDeviceAuthorization(id, provider) {
+      return expectDeviceAuthorization(
+        await transport.request(`${providerPath(id, provider)}/device-authorizations`, {
+          method: "POST"
+        }),
+        "Connection device authorization response",
+        errors
+      );
+    },
+    async pollDeviceAuthorization(id, provider, deviceAuthId) {
+      return expectAuthenticationResult(
+        await transport.request(
+          `${providerPath(id, provider)}/device-authorizations/${encodePathSegment(
+            deviceAuthId,
+            "device authorization id",
+            errors
+          )}/poll`,
+          { method: "POST" }
+        ),
+        "Connection device authorization poll response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/agentCredentials.ts
+function createAgentCredentialsModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const providerSegment = (provider) => encodePathSegment(provider, "provider", errors);
+  return {
+    async list() {
+      return expectObjectArray(
+        await transport.request("/api/v1/credentials", { method: "GET" }),
+        "Credential status response",
+        errors,
+        expectCredentialStatus
+      );
+    },
+    async listModels(agentId) {
+      return expectObjectArray(
+        await transport.request("/api/v1/models", {
+          method: "GET",
+          params: { agentId }
+        }),
+        "Agent model response",
+        errors,
+        expectAgentModel
+      );
+    },
+    async saveApiKey(provider, apiKey) {
+      expectEmpty(
+        await transport.request(
+          `/api/v1/credentials/${providerSegment(provider)}/api-key`,
+          { method: "PUT", body: { apiKey } }
+        ),
+        "Save API key response",
+        errors
+      );
+    },
+    async remove(provider) {
+      expectEmpty(
+        await transport.request(`/api/v1/credentials/${providerSegment(provider)}`, {
+          method: "DELETE"
+        }),
+        "Remove credential response",
+        errors
+      );
+    },
+    async startOAuth(provider) {
+      return expectOAuthStartResult(
+        await transport.request("/api/v1/oauth/start", {
+          method: "POST",
+          body: { provider }
+        }),
+        "OAuth start response",
+        errors
+      );
+    },
+    async exchangeOAuth(provider, input) {
+      return expectAuthenticationResult(
+        await transport.request("/api/v1/oauth/exchange", {
+          method: "POST",
+          body: { provider, ...input }
+        }),
+        "OAuth exchange response",
+        errors
+      );
+    },
+    async startDeviceAuthorization(provider) {
+      return expectDeviceAuthorization(
+        await transport.request(
+          `/api/v1/credentials/${providerSegment(provider)}/device-authorizations`,
+          { method: "POST" }
+        ),
+        "Device authorization response",
+        errors
+      );
+    },
+    async pollDeviceAuthorization(provider, deviceAuthId) {
+      return expectAuthenticationResult(
+        await transport.request(
+          `/api/v1/credentials/${providerSegment(provider)}/device-authorizations/${encodePathSegment(
+            deviceAuthId,
+            "device authorization id",
+            errors
+          )}/poll`,
+          { method: "POST" }
+        ),
+        "Device authorization poll response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/agents.ts
+var MAX_AGENTS = 100;
+function createAgentsModule(functionsTransport, copilotTransport, errors = defaultSdkCoreErrorFactory) {
+  const path = (id) => `/api/v1/agents/${encodePathSegment(id, "agent id", errors)}`;
+  return {
+    async list(options = {}) {
+      const params = {
+        page: options.page,
+        size: options.size,
+        sort: options.sort
+      };
+      return expectPage(
+        await functionsTransport.request("/api/v1/agents", { method: "GET", params }),
+        "Agent page response",
+        errors,
+        expectAgentDefinition
+      );
+    },
+    async get(id) {
+      return expectAgentDefinition(
+        await functionsTransport.request(path(id), { method: "GET" }),
+        "Agent response",
+        errors
+      );
+    },
+    async create(input) {
+      return expectAgentDefinition(
+        await functionsTransport.request("/api/v1/agents", {
+          method: "POST",
+          body: input
+        }),
+        "Create agent response",
+        errors
+      );
+    },
+    async update(id, input) {
+      return expectAgentDefinition(
+        await functionsTransport.request(path(id), { method: "PUT", body: input }),
+        "Update agent response",
+        errors
+      );
+    },
+    async delete(id) {
+      expectEmpty(
+        await functionsTransport.request(path(id), { method: "DELETE" }),
+        "Delete agent response",
+        errors
+      );
+    },
+    async bulkCreate(inputs) {
+      requireBatchSize(inputs, "agents", MAX_AGENTS, errors);
+      return expectObjectArray(
+        await functionsTransport.request("/api/v1/agents/bulk", {
+          method: "POST",
+          body: { agents: inputs }
+        }),
+        "Bulk create agents response",
+        errors,
+        expectAgentDefinition
+      );
+    },
+    async bulkUpdate(items) {
+      requireBatchSize(items, "agents", MAX_AGENTS, errors);
+      return expectObjectArray(
+        await functionsTransport.request("/api/v1/agents/bulk", {
+          method: "PUT",
+          body: { agents: items }
+        }),
+        "Bulk update agents response",
+        errors,
+        expectAgentDefinition
+      );
+    },
+    async bulkDelete(ids) {
+      requireBatchSize(ids, "ids", MAX_AGENTS, errors);
+      return expectAgentBulkDeleteResult(
+        await functionsTransport.request("/api/v1/agents/bulk-delete", {
+          method: "POST",
+          body: { ids }
+        }),
+        "Bulk delete agents response",
+        errors
+      );
+    },
+    async listModels(agentId) {
+      return expectObjectArray(
+        await copilotTransport.request("/api/v1/models", {
+          method: "GET",
+          params: { agentId }
+        }),
+        "Agent model response",
+        errors,
+        expectAgentModel
+      );
+    }
+  };
+}
+
+// src/modules/agentTasks.ts
+function createAgentTasksModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const path = (id) => `/api/v1/tasks/${encodePathSegment(id, "task id", errors)}`;
+  return {
+    async list(options = {}) {
+      const params = {
+        page: options.page,
+        size: options.size,
+        sort: options.sort,
+        archived: options.archived,
+        agentId: options.agentId,
+        search: options.search,
+        userId: options.userId
+      };
+      return expectPage(
+        await transport.request("/api/v1/tasks", { method: "GET", params }),
+        "Agent task page response",
+        errors,
+        expectAgentTask
+      );
+    },
+    async get(id) {
+      return expectAgentTask(
+        await transport.request(path(id), { method: "GET" }),
+        "Agent task response",
+        errors
+      );
+    },
+    async create(input) {
+      return expectAgentTask(
+        await transport.request("/api/v1/tasks", { method: "POST", body: input }),
+        "Create agent task response",
+        errors
+      );
+    },
+    async rename(id, title) {
+      return expectAgentTask(
+        await transport.request(path(id), { method: "PATCH", body: { title } }),
+        "Rename agent task response",
+        errors
+      );
+    },
+    async archive(id) {
+      expectEmpty(
+        await transport.request(`${path(id)}/archive`, { method: "PATCH" }),
+        "Archive agent task response",
+        errors
+      );
+    },
+    async sendInput(id, input) {
+      expectEmpty(
+        await transport.request(`${path(id)}/inputs`, { method: "POST", body: input }),
+        "Agent task input response",
+        errors
+      );
+    },
+    async listMessages(id, options = {}) {
+      return expectPage(
+        await transport.request(`${path(id)}/messages`, {
+          method: "GET",
+          params: { page: options.page, size: options.size, sort: options.sort }
+        }),
+        "Agent message page response",
+        errors,
+        expectAgentMessage
+      );
+    }
+  };
+}
+
+// src/modules/apps.ts
+function createAppsModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const appPath = (appId) => `/api/v1/apps/${encodePathSegment(appId, "app id", errors)}`;
+  const params = (options = {}, defaultSort) => ({
+    page: options.page,
+    size: options.size,
+    sort: options.sort ?? defaultSort
+  });
+  return {
+    async list(options = {}) {
+      return expectPage(
+        await transport.request("/api/v1/apps", {
+          method: "GET",
+          params: {
+            ...params(options, "createdAt,desc"),
+            search: options.search,
+            version: options.version,
+            brand: options.brand
+          }
+        }),
+        "App page response",
+        errors,
+        expectAppSummary
+      );
+    },
+    async get(appId, options = {}) {
+      return expectAppDefinition(
+        await transport.request(appPath(appId), {
+          method: "GET",
+          params: { version: options.version }
+        }),
+        "App response",
+        errors
+      );
+    },
+    async create(input) {
+      return expectAppDefinition(
+        await transport.request("/api/v1/apps", { method: "POST", body: input }),
+        "Create app response",
+        errors
+      );
+    },
+    async delete(appId) {
+      expectEmpty(
+        await transport.request(appPath(appId), { method: "DELETE" }),
+        "Delete app response",
+        errors
+      );
+    },
+    async update(appId, input) {
+      return expectAppDefinition(
+        await transport.request(appPath(appId), { method: "PATCH", body: input }),
+        "Update app response",
+        errors
+      );
+    },
+    async getFiles(appId) {
+      return expectFiles(
+        await transport.request(`${appPath(appId)}/files`, { method: "GET" }),
+        errors
+      );
+    },
+    async replaceFiles(appId, files) {
+      return expectFiles(
+        await transport.request(`${appPath(appId)}/files`, {
+          method: "PUT",
+          body: { files }
+        }),
+        errors
+      );
+    },
+    async mergeFiles(appId, files) {
+      return expectFiles(
+        await transport.request(`${appPath(appId)}/files`, {
+          method: "PATCH",
+          body: { files }
+        }),
+        errors
+      );
+    },
+    async build(appId) {
+      return expectAppDeploy(
+        await transport.request(`${appPath(appId)}/build`, { method: "POST" }),
+        "Build app deploy response",
+        errors
+      );
+    },
+    async publish(appId, options = {}) {
+      return expectAppDefinition(
+        await transport.request(`${appPath(appId)}/publish`, {
+          method: "POST",
+          body: options.externalAccess === void 0 ? void 0 : options
+        }),
+        "Publish app response",
+        errors
+      );
+    },
+    async getDeploy(appId, deployId) {
+      return expectAppDeploy(
+        await transport.request(
+          `${appPath(appId)}/deploys/${encodePathSegment(deployId, "deploy id", errors)}`,
+          { method: "GET" }
+        ),
+        "App deploy response",
+        errors
+      );
+    },
+    async getCurrentDeploy(appId) {
+      const response = await transport.request(`${appPath(appId)}/deploys/current`, {
+        method: "GET"
+      });
+      return response === null || response === void 0 ? null : expectAppDeploy(response, "Current app deploy response", errors);
+    },
+    async cancelBuild(appId, deployId) {
+      return expectAppDeploy(
+        await transport.request(
+          `${appPath(appId)}/deploys/${encodePathSegment(deployId, "deploy id", errors)}/cancel`,
+          { method: "POST" }
+        ),
+        "Cancel app build response",
+        errors
+      );
+    },
+    async rollback(appId, targetVersionId) {
+      return expectAppDefinition(
+        await transport.request(`${appPath(appId)}/rollback`, {
+          method: "POST",
+          body: { targetVersionId }
+        }),
+        "Rollback app response",
+        errors
+      );
+    },
+    async listDeploys(appId, options = {}) {
+      return expectPage(
+        await transport.request(`${appPath(appId)}/deploys`, {
+          method: "GET",
+          params: params(options, "createdAt,desc")
+        }),
+        "App deploy page response",
+        errors,
+        expectAppDeploy
+      );
+    },
+    async listVersions(appId, options = {}) {
+      return expectPage(
+        await transport.request(`${appPath(appId)}/versions`, {
+          method: "GET",
+          params: params(options, "createdAt,desc")
+        }),
+        "App version page response",
+        errors,
+        expectAppVersion
+      );
+    }
+  };
+}
+function expectFiles(value, errors) {
+  const response = expectObject(value, "App files response", errors);
+  if (response.files === null || typeof response.files !== "object" || Array.isArray(response.files) || Object.values(response.files).some((content) => typeof content !== "string")) {
+    throw errors.invalidResponse("App files response has an invalid files field");
+  }
+  return response;
+}
+
+// src/modules/auth.ts
+function createAuthModule(transport, errors = defaultSdkCoreErrorFactory) {
+  return {
+    async me() {
+      return expectUser(
+        await transport.request("/api/v1/auth/me", { method: "GET" }),
+        "Current user response",
+        errors
+      );
+    },
+    async listUserPlans() {
+      return expectObjectArray(
+        await transport.request("/api/v1/user-plans", { method: "GET" }),
+        "User plan response",
+        errors,
+        expectUserPlan
+      );
+    }
+  };
+}
+
+// src/modules/context.ts
+var SUMMARY_PAGE_SIZE = 2e3;
+function createContextModule(dependencies, errors = defaultSdkCoreErrorFactory) {
+  return {
+    async getAppContext() {
+      const appId = dependencies.getAppId?.();
+      if (!appId) {
+        configurationError("An appId is required for app context", errors);
+      }
+      const app = await dependencies.apps.get(appId);
+      const tables = await dependencies.schema.listTables({ scope: "APP", includeColumns: true });
+      const functionsPage = await dependencies.functionsAdmin.list({
+        page: 0,
+        size: SUMMARY_PAGE_SIZE,
+        sort: "name"
+      });
+      const agentsPage = await dependencies.agents.list({
+        page: 0,
+        size: SUMMARY_PAGE_SIZE,
+        sort: "name"
+      });
+      const fileResponse = await dependencies.apps.getFiles(appId);
+      const integrationsPage = await dependencies.integrationAdmin.list({
+        page: 0,
+        size: SUMMARY_PAGE_SIZE,
+        sort: "alias"
+      });
+      const connections = await dependencies.agentConnections.list();
+      return {
+        appId,
+        app,
+        tables,
+        functions: functionsPage.content,
+        functionsTotal: functionsPage.page.totalElements,
+        functionsTruncated: functionsPage.content.length < functionsPage.page.totalElements,
+        agents: agentsPage.content,
+        agentsTotal: agentsPage.page.totalElements,
+        agentsTruncated: agentsPage.content.length < agentsPage.page.totalElements,
+        files: Object.keys(fileResponse.files).sort(),
+        integrations: integrationsPage.content,
+        integrationsTotal: integrationsPage.totalElements,
+        integrationsTruncated: integrationsPage.content.length < integrationsPage.totalElements,
+        connections
+      };
+    }
+  };
+}
+
+// src/modules/customQueries.ts
+function createCustomQueriesModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const path = (id) => `/api/v1/custom-queries/${encodePathSegment(id, "query id", errors)}`;
+  return {
+    async list(options = {}) {
+      const params = {
+        page: options.page,
+        size: options.size ?? 20,
+        sort: options.sort ?? "name"
+      };
+      return expectPage(
+        await transport.request("/api/v1/custom-queries", { method: "GET", params }),
+        "Custom query page response",
+        errors,
+        expectCustomQuerySummary
+      );
+    },
+    async get(id) {
+      return expectCustomQueryDefinition(
+        await transport.request(path(id), { method: "GET" }),
+        "Custom query response",
+        errors
+      );
+    },
+    async create(input) {
+      return expectCustomQueryDefinition(
+        await transport.request("/api/v1/custom-queries", { method: "POST", body: input }),
+        "Create custom query response",
+        errors
+      );
+    },
+    async update(id, input) {
+      return expectCustomQueryDefinition(
+        await transport.request(path(id), { method: "PUT", body: input }),
+        "Update custom query response",
+        errors
+      );
+    },
+    async delete(id) {
+      expectEmpty(
+        await transport.request(path(id), { method: "DELETE" }),
+        "Delete custom query response",
+        errors
+      );
+    },
+    async execute(id, parameters = {}) {
+      return expectQueryResult(
+        await transport.request(`${path(id)}/execute`, {
+          method: "POST",
+          body: { parameters }
+        }),
+        "Custom query execution response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/dataSources.ts
+var MAX_DATA_SOURCES = 100;
+function bulkFailure(index, dataSourceId, error) {
+  const errorCode2 = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
+  return {
+    index,
+    success: false,
+    dataSourceId,
+    errorCode: errorCode2,
+    message: error instanceof Error ? error.message : "Data Source operation failed"
+  };
+}
+function bulkResult(results) {
+  const succeededCount = results.filter(({ success }) => success).length;
+  return {
+    results,
+    processedCount: results.length,
+    succeededCount,
+    failedCount: results.length - succeededCount
+  };
+}
+function createDataSourcesModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const path = (id) => `/api/v1/data-sources/${encodePathSegment(id, "data source id", errors)}`;
+  const createOne = async (input) => expectDataSourceDefinition(
+    await transport.request("/api/v1/data-sources", { method: "POST", body: input }),
+    "Create Data Source response",
+    errors
+  );
+  const updateOne = async (id, input) => expectDataSourceDefinition(
+    await transport.request(path(id), { method: "PUT", body: input }),
+    "Update Data Source response",
+    errors
+  );
+  const deleteOne = async (id) => {
+    expectEmpty(
+      await transport.request(path(id), { method: "DELETE" }),
+      "Delete Data Source response",
+      errors
+    );
+  };
+  return {
+    async list(options = {}) {
+      const params = {
+        page: options.page,
+        size: options.size,
+        sort: options.sort
+      };
+      return expectPage(
+        await transport.request("/api/v1/data-sources", { method: "GET", params }),
+        "Data Source page response",
+        errors,
+        expectDataSourceDefinition
+      );
+    },
+    async get(id) {
+      return expectDataSourceDefinition(
+        await transport.request(path(id), { method: "GET" }),
+        "Data Source response",
+        errors
+      );
+    },
+    async create(input) {
+      return createOne(input);
+    },
+    async update(id, input) {
+      return updateOne(id, input);
+    },
+    async delete(id) {
+      return deleteOne(id);
+    },
+    async bulkCreate(dataSources) {
+      requireBatchSize(dataSources, "dataSources", MAX_DATA_SOURCES, errors);
+      const results = [];
+      for (const [index, input] of dataSources.entries()) {
+        try {
+          const created = await createOne(input);
+          results.push({
+            index,
+            success: true,
+            dataSourceId: created.id,
+            errorCode: null,
+            message: null
+          });
+        } catch (error) {
+          results.push(bulkFailure(index, null, error));
+        }
+      }
+      return bulkResult(results);
+    },
+    async bulkUpdate(dataSources) {
+      requireBatchSize(dataSources, "dataSources", MAX_DATA_SOURCES, errors);
+      const paths = dataSources.map(({ dataSourceId }) => path(dataSourceId));
+      const results = [];
+      for (const [index, { dataSourceId, ...input }] of dataSources.entries()) {
+        try {
+          const updated = expectDataSourceDefinition(
+            await transport.request(paths[index], { method: "PUT", body: input }),
+            "Update Data Source response",
+            errors
+          );
+          results.push({
+            index,
+            success: true,
+            dataSourceId: updated.id,
+            errorCode: null,
+            message: null
+          });
+        } catch (error) {
+          results.push(bulkFailure(index, dataSourceId, error));
+        }
+      }
+      return bulkResult(results);
+    },
+    async bulkDelete(dataSourceIds) {
+      requireBatchSize(dataSourceIds, "dataSourceIds", MAX_DATA_SOURCES, errors);
+      const paths = dataSourceIds.map((id) => path(id));
+      const results = [];
+      for (const [index, dataSourceId] of dataSourceIds.entries()) {
+        try {
+          expectEmpty(
+            await transport.request(paths[index], { method: "DELETE" }),
+            "Delete Data Source response",
+            errors
+          );
+          results.push({ index, success: true, dataSourceId, errorCode: null, message: null });
+        } catch (error) {
+          results.push(bulkFailure(index, dataSourceId, error));
+        }
+      }
+      return bulkResult(results);
+    }
+  };
+}
+
+// src/modules/entities.ts
+var DefaultEntitiesModule = class {
+  constructor(transport, errors) {
+    this.transport = transport;
+    this.errors = errors;
+  }
+  tables = /* @__PURE__ */ new Map();
+  getTable(tableName) {
+    if (!this.tables.has(tableName)) {
+      this.tables.set(tableName, this.createTable(tableName));
+    }
+    return this.tables.get(tableName);
+  }
+  createTable(tableName) {
+    const basePath = `/api/v1/tables/${encodePathSegment(tableName, "tableName", this.errors)}/records`;
+    return {
+      list: async (sortOrOptions, limit, skip, fields) => {
+        const options = typeof sortOrOptions === "object" ? sortOrOptions : void 0;
+        const params = {
+          sort: options?.sort ?? (typeof sortOrOptions === "string" ? sortOrOptions : void 0),
+          limit: options?.limit ?? limit,
+          skip: options?.skip ?? skip,
+          fields: (options?.fields ?? fields)?.join(",")
+        };
+        return expectEntityListResponse(
+          await this.transport.request(basePath, { method: "GET", params }),
+          "Entity list response",
+          this.errors
+        );
+      },
+      filter: async (query, sort, limit, skip, fields) => {
+        return expectEntityListResponse(
+          await this.transport.request(basePath, {
+            method: "GET",
+            params: {
+              q: JSON.stringify(query),
+              sort,
+              limit,
+              skip,
+              fields: fields?.join(",")
+            }
+          }),
+          "Entity list response",
+          this.errors
+        );
+      },
+      get: async (id) => expectObject(
+        await this.transport.request(
+          `${basePath}/${encodePathSegment(id, "id", this.errors)}`,
+          { method: "GET" }
+        ),
+        "Entity response",
+        this.errors
+      ),
+      create: async (data) => expectObject(
+        await this.transport.request(basePath, { method: "POST", body: data }),
+        "Created entity response",
+        this.errors
+      ),
+      bulkCreate: async (data) => expectObjectArray(
+        await this.transport.request(`${basePath}/bulk`, {
+          method: "POST",
+          body: data
+        }),
+        "Bulk create response",
+        this.errors
+      ),
+      update: async (id, data) => expectObject(
+        await this.transport.request(
+          `${basePath}/${encodePathSegment(id, "id", this.errors)}`,
+          { method: "PUT", body: data }
+        ),
+        "Updated entity response",
+        this.errors
+      ),
+      delete: (id) => this.transport.request(`${basePath}/${encodePathSegment(id, "id", this.errors)}`, {
+        method: "DELETE"
+      }).then((response) => expectEmpty(response, "Delete entity response", this.errors)),
+      deleteMany: async (query) => {
+        if (Object.keys(query).length === 0) {
+          configurationError("query must not be empty for deleteMany", this.errors);
+        }
+        const response = expectObject(
+          await this.transport.request(basePath, {
+            method: "DELETE",
+            params: { q: JSON.stringify(query) }
+          }),
+          "Delete many response",
+          this.errors
+        );
+        if (!Number.isInteger(response.deleted)) {
+          return invalidResponse(
+            "Delete many response must include an integer deleted count",
+            this.errors
+          );
+        }
+        return { deleted: response.deleted };
+      }
+    };
+  }
+};
+function expectEntityListResponse(value, context, errors) {
+  const response = expectObject(value, context, errors);
+  expectObjectArray(response.data, `${context} data`, errors);
+  if (!Number.isInteger(response.limit))
+    invalidResponse(`${context} has an invalid limit field`, errors);
+  if (!Number.isInteger(response.skip))
+    invalidResponse(`${context} has an invalid skip field`, errors);
+  if (!Number.isInteger(response.total))
+    invalidResponse(`${context} has an invalid total field`, errors);
+  if (typeof response.hasMore !== "boolean") {
+    invalidResponse(`${context} has an invalid hasMore field`, errors);
+  }
+  return response;
+}
+function createEntitiesModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const instance = new DefaultEntitiesModule(transport, errors);
+  return new Proxy(instance, {
+    get(target, property, receiver) {
+      if (typeof property !== "string" || property in target) {
+        return Reflect.get(target, property, receiver);
+      }
+      return target.getTable(property);
+    }
+  });
+}
+
+// src/modules/functions.ts
+var DefaultFunctionsModule = class {
+  constructor(transport, errors, options) {
+    this.transport = transport;
+    this.errors = errors;
+    this.options = options;
+  }
+  execute(id, input) {
+    return this.executeWithType(id, this.options.executeInvocationType, input);
+  }
+  executeAsync(id, input) {
+    return this.executeWithType(id, "async", input);
+  }
+  getExecution(id) {
+    return this.transport.request(
+      `/api/v1/executions/${encodePathSegment(id, "execution id", this.errors)}`,
+      { method: "GET" }
+    ).then(
+      (response) => expectFunctionExecution(response, "Function execution response", this.errors)
+    );
+  }
+  cancelExecution(id) {
+    return this.transport.request(
+      `/api/v1/executions/${encodePathSegment(id, "execution id", this.errors)}/cancel`,
+      { method: "POST" }
+    ).then((response) => expectEmpty(response, "Cancel execution response", this.errors));
+  }
+  executeWithType(id, invocationType, input) {
+    const request = {
+      method: "POST",
+      ...input !== void 0 || this.options.emptyInput !== "omit-body" ? { body: { input: input ?? {} } } : {},
+      ...invocationType === void 0 ? {} : { headers: { "X-Invocation-Type": invocationType } }
+    };
+    return this.transport.request(
+      `/api/v1/functions/${encodePathSegment(id, "function id", this.errors)}/execute`,
+      request
+    ).then(
+      (response) => expectFunctionExecution(response, "Function execution response", this.errors)
+    );
+  }
+};
+function createFunctionsModule(transport, options = {}, errors = defaultSdkCoreErrorFactory) {
+  return new DefaultFunctionsModule(transport, errors, options);
+}
+
+// src/modules/functionsAdmin.ts
+var MAX_FUNCTIONS = 100;
+var COMPOSED_SCHEDULE_FIELDS = ["cronExpression", "cronInputJson", "cronEnabled"];
+function rejectBulkScheduleFields(value, operation, errors) {
+  if (typeof value !== "object" || value === null) return;
+  const field = COMPOSED_SCHEDULE_FIELDS.find((candidate) => Object.hasOwn(value, candidate));
+  if (field) {
+    configurationError(
+      `functionsAdmin.${operation} does not support ${field}; composed scheduling is supported only by single-Function create and patch`,
+      errors
+    );
+  }
+}
+function bulkPatchUpdate(value) {
+  return typeof value === "object" && value !== null && Object.hasOwn(value, "update") ? value.update : void 0;
+}
+function createFunctionsAdminModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const functionPath = (id) => `/api/v1/functions/${encodePathSegment(id, "function id", errors)}`;
+  const pageParams = (options = {}) => ({
+    page: options.page,
+    size: options.size,
+    sort: options.sort
+  });
+  return {
+    async list(options = {}) {
+      return expectPage(
+        await transport.request("/api/v1/functions", {
+          method: "GET",
+          params: { ...pageParams(options), search: options.search }
+        }),
+        "Function page response",
+        errors,
+        expectFunctionSummary
+      );
+    },
+    async get(id) {
+      return expectFunctionDefinition(
+        await transport.request(functionPath(id), { method: "GET" }),
+        "Function response",
+        errors
+      );
+    },
+    async create(input) {
+      return expectFunctionDefinition(
+        await transport.request("/api/v1/functions", { method: "POST", body: input }),
+        "Create Function response",
+        errors
+      );
+    },
+    async patch(id, input) {
+      return expectFunctionDefinition(
+        await transport.request(functionPath(id), { method: "PATCH", body: input }),
+        "Patch Function response",
+        errors
+      );
+    },
+    async delete(id) {
+      expectEmpty(
+        await transport.request(functionPath(id), { method: "DELETE" }),
+        "Delete Function response",
+        errors
+      );
+    },
+    async bulkCreate(functions) {
+      requireBatchSize(functions, "functions", MAX_FUNCTIONS, errors);
+      functions.forEach((input) => rejectBulkScheduleFields(input, "bulkCreate", errors));
+      return expectFunctionDefinitions(
+        await transport.request("/api/v1/functions/bulk", {
+          method: "POST",
+          body: { functions }
+        }),
+        "Function bulk create response",
+        errors
+      );
+    },
+    async bulkUpdate(functions) {
+      requireBatchSize(functions, "functions", MAX_FUNCTIONS, errors);
+      return expectFunctionDefinitions(
+        await transport.request("/api/v1/functions/bulk", {
+          method: "PUT",
+          body: { functions }
+        }),
+        "Function bulk update response",
+        errors
+      );
+    },
+    async bulkPatch(functions) {
+      requireBatchSize(functions, "functions", MAX_FUNCTIONS, errors);
+      functions.forEach(
+        (item) => rejectBulkScheduleFields(bulkPatchUpdate(item), "bulkPatch", errors)
+      );
+      return expectFunctionDefinitions(
+        await transport.request("/api/v1/functions/bulk", {
+          method: "PATCH",
+          body: { functions }
+        }),
+        "Function bulk patch response",
+        errors
+      );
+    },
+    // POST, not DELETE: the selector travels in a body, and some proxies drop a DELETE body.
+    async bulkDelete(selector) {
+      const body = selectorBody(selector, errors);
+      return expectFunctionBulkDeleteResult(
+        await transport.request("/api/v1/functions/bulk-delete", {
+          method: "POST",
+          body
+        }),
+        "Function bulk delete response",
+        errors
+      );
+    },
+    async publish(id) {
+      return expectFunctionDefinition(
+        await transport.request(`${functionPath(id)}/publish`, { method: "POST" }),
+        "Publish Function response",
+        errors
+      );
+    },
+    async rollback(id, versionId) {
+      return expectFunctionDefinition(
+        await transport.request(`${functionPath(id)}/rollback`, {
+          method: "POST",
+          body: { targetVersionId: versionId }
+        }),
+        "Rollback Function response",
+        errors
+      );
+    },
+    async listVersions(id, options = {}) {
+      return expectPage(
+        await transport.request(`${functionPath(id)}/versions`, {
+          method: "GET",
+          params: pageParams(options)
+        }),
+        "Function version page response",
+        errors,
+        expectFunctionVersionResponse
+      );
+    },
+    async setVisibility(id, visibility) {
+      return expectFunctionDefinition(
+        await transport.request(`${functionPath(id)}/visibility`, {
+          method: "PATCH",
+          body: { visibility }
+        }),
+        "Function visibility response",
+        errors
+      );
+    },
+    async listExecutions(id, options = {}) {
+      return expectPage(
+        await transport.request(`${functionPath(id)}/executions`, {
+          method: "GET",
+          params: pageParams(options)
+        }),
+        "Function execution page response",
+        errors,
+        expectFunctionExecution
+      );
+    },
+    async getExecution(functionId, executionId) {
+      return expectFunctionExecution(
+        await transport.request(
+          `${functionPath(functionId)}/executions/${encodePathSegment(
+            executionId,
+            "execution id",
+            errors
+          )}`,
+          { method: "GET" }
+        ),
+        "Function execution response",
+        errors
+      );
+    },
+    async listSecrets(id) {
+      return expectFunctionSecrets(
+        await transport.request(`${functionPath(id)}/secrets`, { method: "GET" }),
+        "Function secrets response",
+        errors
+      );
+    },
+    async createSecret(id, name, value) {
+      expectEmpty(
+        await transport.request(`${functionPath(id)}/secrets`, {
+          method: "POST",
+          body: { name, value }
+        }),
+        "Create Function secret response",
+        errors
+      );
+    },
+    async deleteSecret(id, name) {
+      expectEmpty(
+        await transport.request(
+          `${functionPath(id)}/secrets/${encodePathSegment(name, "secret name", errors)}`,
+          { method: "DELETE" }
+        ),
+        "Delete Function secret response",
+        errors
+      );
+    }
+  };
+}
+function selectorBody(selector, errors) {
+  const hasIds = selector.ids !== void 0;
+  if (hasIds === (selector.allInApp === true)) {
+    configurationError("Provide either ids or allInApp, not both", errors);
+  }
+  if (selector.ids !== void 0) {
+    requireBatchSize(selector.ids, "ids", MAX_FUNCTIONS, errors);
+    return { ids: selector.ids };
+  }
+  return { allInApp: true };
+}
+
+// src/modules/imports.ts
+function createImportsModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const path = (id) => `/api/v1/data-imports/${encodePathSegment(id, "import id", errors)}`;
+  const pageParams = (options = {}) => ({
+    page: options.page,
+    size: options.size,
+    sort: options.sort
+  });
+  return {
+    async list(options = {}) {
+      return expectPage(
+        await transport.request("/api/v1/data-imports", {
+          method: "GET",
+          params: pageParams(options)
+        }),
+        "Import page response",
+        errors,
+        expectImportDefinition
+      );
+    },
+    async get(id) {
+      return expectImportDefinition(
+        await transport.request(path(id), { method: "GET" }),
+        "Import response",
+        errors
+      );
+    },
+    async create(input) {
+      return expectImportDefinition(
+        await transport.request("/api/v1/data-imports", { method: "POST", body: input }),
+        "Create import response",
+        errors
+      );
+    },
+    async update(id, input) {
+      return expectImportDefinition(
+        await transport.request(path(id), { method: "PUT", body: input }),
+        "Update import response",
+        errors
+      );
+    },
+    async delete(id) {
+      expectEmpty(
+        await transport.request(path(id), { method: "DELETE" }),
+        "Delete import response",
+        errors
+      );
+    },
+    async execute(id) {
+      return expectImportExecution(
+        await transport.request(`${path(id)}/execute`, { method: "POST" }),
+        "Import execution response",
+        errors
+      );
+    },
+    async listExecutions(options) {
+      return expectPage(
+        await transport.request("/api/v1/data-imports/executions", {
+          method: "GET",
+          params: {
+            definitionId: options.definitionId,
+            page: options.page,
+            size: options.size,
+            sort: options.sort ?? "queuedAt,desc"
+          }
+        }),
+        "Import execution page response",
+        errors,
+        expectImportExecution
+      );
+    },
+    async cancelExecution(executionId) {
+      return expectImportExecution(
+        await transport.request(
+          `/api/v1/data-imports/executions/${encodePathSegment(executionId, "execution id", errors)}/cancel`,
+          { method: "POST" }
+        ),
+        "Cancel import execution response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/integration.ts
 function createIntegrationModule(transport, errors = defaultSdkCoreErrorFactory) {
   return {
     async executeResource(resourceId, params = {}) {
@@ -375,13 +2369,356 @@ function createIntegrationModule(transport, errors = defaultSdkCoreErrorFactory)
         errors
       );
     },
-    async execute(configId, request) {
-      return expectProxyResult(
+    async execute(configId, request) {
+      return expectProxyResult(
+        await transport.request(
+          `/api/v1/proxy/template-configs/${encodePathSegment(configId, "config id", errors)}/execute`,
+          { method: "POST", body: { ...request, source: "SDK" } }
+        ),
+        "Integration proxy response",
+        errors
+      );
+    },
+    async executeByAlias(alias, request) {
+      return expectProxyResult(
+        await transport.request(
+          `/api/v1/proxy/template-configs/by-alias/${encodePathSegment(alias, "alias", errors)}/execute`,
+          { method: "POST", body: { ...request, source: "SDK" } }
+        ),
+        "Integration proxy response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/integrationAdmin.ts
+var MAX_CONFIGS = 100;
+function createIntegrationAdminModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const path = (id) => `/api/v1/template-configs/${encodePathSegment(id, "config id", errors)}`;
+  return {
+    async create(input) {
+      return expectTemplateConfig(
+        await transport.request("/api/v1/template-configs", {
+          method: "POST",
+          body: input
+        }),
+        "Create integration config response",
+        errors
+      );
+    },
+    async update(id, input) {
+      return expectTemplateConfig(
+        await transport.request(path(id), { method: "PUT", body: input }),
+        "Update integration config response",
+        errors
+      );
+    },
+    async delete(id) {
+      expectEmpty(
+        await transport.request(path(id), { method: "DELETE" }),
+        "Delete integration config response",
+        errors
+      );
+    },
+    async bulkCreate(configs) {
+      requireBatchSize(configs, "configs", MAX_CONFIGS, errors);
+      return expectTemplateConfigBulkResult(
+        await transport.request("/api/v1/template-configs/bulk", {
+          method: "POST",
+          body: { configs }
+        }),
+        "Template config bulk create response",
+        errors
+      );
+    },
+    async bulkUpdate(configs) {
+      requireBatchSize(configs, "configs", MAX_CONFIGS, errors);
+      return expectTemplateConfigBulkResult(
+        await transport.request("/api/v1/template-configs/bulk", {
+          method: "PUT",
+          body: { configs }
+        }),
+        "Template config bulk update response",
+        errors
+      );
+    },
+    // POST, not DELETE: the id list travels in a body, and some proxies drop a DELETE body.
+    async bulkDelete(configIds) {
+      requireBatchSize(configIds, "configIds", MAX_CONFIGS, errors);
+      return expectTemplateConfigBulkResult(
+        await transport.request("/api/v1/template-configs/bulk-delete", {
+          method: "POST",
+          body: { configIds }
+        }),
+        "Template config bulk delete response",
+        errors
+      );
+    },
+    async testCredentials(request) {
+      return expectConnectionTestResult(
+        await transport.request("/api/v1/template-configs/test", {
+          method: "POST",
+          body: request
+        }),
+        "Integration credentials test response",
+        errors
+      );
+    },
+    async testConfig(configId) {
+      return expectConnectionTestResult(
+        await transport.request(`${path(configId)}/test`, { method: "POST" }),
+        "Integration config test response",
+        errors
+      );
+    },
+    async list(options = {}) {
+      const params = {
+        page: options.page,
+        size: options.size,
+        sort: options.sort
+      };
+      return expectTemplateConfigPage(
+        await transport.request("/api/v1/template-configs", { method: "GET", params }),
+        "Template config page response",
+        errors
+      );
+    },
+    async listExecutions(configId, options = {}) {
+      return expectLegacyPage(
+        await transport.request(`${path(configId)}/executions`, {
+          method: "GET",
+          params: {
+            page: options.page,
+            size: options.size,
+            sort: options.sort ?? "createdAt,desc"
+          }
+        }),
+        "Integration execution page response",
+        errors,
+        expectIntegrationExecution
+      );
+    },
+    async getExecution(configId, executionId) {
+      return expectIntegrationExecution(
+        await transport.request(
+          `${path(configId)}/executions/${encodePathSegment(executionId, "execution id", errors)}`,
+          { method: "GET" }
+        ),
+        "Integration execution response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/integrationResources.ts
+function createIntegrationResourcesModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const path = (id) => `/api/v1/integration-resources/${encodePathSegment(id, "resource id", errors)}`;
+  return {
+    async list(options = {}) {
+      const params = {
+        page: options.page,
+        size: options.size,
+        sort: options.sort
+      };
+      return expectLegacyPage(
+        await transport.request("/api/v1/integration-resources", {
+          method: "GET",
+          params
+        }),
+        "Integration resource page response",
+        errors,
+        expectIntegrationResourceSummary
+      );
+    },
+    async get(id) {
+      return expectIntegrationResource(
+        await transport.request(path(id), { method: "GET" }),
+        "Integration resource response",
+        errors
+      );
+    },
+    async create(input) {
+      return expectIntegrationResource(
+        await transport.request("/api/v1/integration-resources", {
+          method: "POST",
+          body: input
+        }),
+        "Create integration resource response",
+        errors
+      );
+    },
+    async update(id, input) {
+      return expectIntegrationResource(
+        await transport.request(path(id), { method: "PUT", body: input }),
+        "Update integration resource response",
+        errors
+      );
+    },
+    async delete(id) {
+      expectEmpty(
+        await transport.request(path(id), { method: "DELETE" }),
+        "Delete integration resource response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/integrationTemplates.ts
+function createIntegrationTemplatesModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const params = (options = {}, sort) => ({
+    page: options.page,
+    size: options.size ?? 20,
+    sort: options.sort ?? sort
+  });
+  return {
+    async list(options = {}) {
+      return expectLegacyPage(
+        await transport.request("/api/v1/templates", {
+          method: "GET",
+          params: params(options, "name")
+        }),
+        "Integration template page response",
+        errors,
+        expectIntegrationTemplateSummary
+      );
+    },
+    async get(id) {
+      return expectIntegrationTemplate(
+        await transport.request(
+          `/api/v1/templates/${encodePathSegment(id, "template id", errors)}`,
+          { method: "GET" }
+        ),
+        "Integration template response",
+        errors
+      );
+    },
+    async listConfigs(options = {}) {
+      return expectLegacyPage(
+        await transport.request("/api/v1/template-configs", {
+          method: "GET",
+          params: params(options, "alias")
+        }),
+        "Integration config page response",
+        errors,
+        expectTemplateConfigSummary
+      );
+    },
+    async getConfig(id) {
+      return expectTemplateConfig(
+        await transport.request(
+          `/api/v1/template-configs/${encodePathSegment(id, "config id", errors)}`,
+          { method: "GET" }
+        ),
+        "Integration config response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/members.ts
+var MAX_APP_USERS = 100;
+function createMembersModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const path = (appId) => `/api/v1/apps/${encodePathSegment(appId, "app id", errors)}/users`;
+  return {
+    async list() {
+      return expectAppMembers(
+        await transport.request("/api/v1/members/current-app", { method: "GET" }),
+        "App members response",
+        errors
+      );
+    },
+    async invite(appId, input) {
+      expectEmpty(
+        await transport.request(path(appId), { method: "POST", body: input }),
+        "Invite app user response",
+        errors
+      );
+    },
+    async unsubscribe(appId, userId) {
+      expectEmpty(
         await transport.request(
-          `/api/v1/proxy/template-configs/${encodePathSegment(configId, "config id", errors)}/execute`,
-          { method: "POST", body: { ...request, source: "SDK" } }
+          `${path(appId)}/${encodePathSegment(userId, "user id", errors)}`,
+          { method: "DELETE" }
         ),
-        "Integration proxy response",
+        "Unsubscribe app user response",
+        errors
+      );
+    },
+    async bulkInvite(appId, users) {
+      requireBatchSize(users, "users", MAX_APP_USERS, errors);
+      expectEmpty(
+        await transport.request(`${path(appId)}/bulk`, {
+          method: "POST",
+          body: { users }
+        }),
+        "Bulk invite app users response",
+        errors
+      );
+    },
+    async bulkUnsubscribe(appId, userIds) {
+      requireBatchSize(userIds, "userIds", MAX_APP_USERS, errors);
+      return expectBulkUnsubscribeResult(
+        await transport.request(`${path(appId)}/bulk-unsubscribe`, {
+          method: "POST",
+          body: { userIds }
+        }),
+        "Bulk unsubscribe app users response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/messenger.ts
+function createMessengerModule(transport, errors = defaultSdkCoreErrorFactory) {
+  return {
+    async notify(content) {
+      return expectMessageAccepted(
+        await transport.request("/api/v1/messages/notify", {
+          method: "POST",
+          body: { content }
+        }),
+        "Notify user response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/publicFunctions.ts
+function createPublicFunctionsModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const execute = async (id, input, mode) => {
+    if (!transport) {
+      configurationError(
+        "A separate publicFunctions transport is required so anonymous requests do not inherit authorization headers",
+        errors
+      );
+    }
+    return transport.request(
+      `/public/v1/functions/${encodePathSegment(id, "function id", errors)}/execute`,
+      {
+        method: "POST",
+        headers: { "X-Invocation-Type": mode },
+        body: { input: input ?? {} }
+      }
+    );
+  };
+  return {
+    async execute(id, input) {
+      return expectPublicFunctionResult(
+        await execute(id, input, "sync"),
+        "Public Function execution response",
+        errors
+      );
+    },
+    async executeAsync(id, input) {
+      return expectPublicFunctionAsyncResult(
+        await execute(id, input, "async"),
+        "Public async Function execution response",
         errors
       );
     }
@@ -389,22 +2726,15 @@ function createIntegrationModule(transport, errors = defaultSdkCoreErrorFactory)
 }
 
 // src/modules/queries.ts
-function createQueriesModule(transport, getDataSourceId, errors = defaultSdkCoreErrorFactory) {
+function createQueriesModule(transport, errors = defaultSdkCoreErrorFactory) {
   return {
     async execute(id, parameters = {}) {
-      const dataSourceId = getDataSourceId();
-      if (!dataSourceId) {
-        configurationError(
-          "A dataSourceId is required for queries. Call client.init() first or configure dataSourceId.",
-          errors
-        );
-      }
       return expectQueryResult(
         await transport.request(
           `/api/v1/custom-queries/${encodePathSegment(id, "query id", errors)}/execute`,
           {
             method: "POST",
-            body: { dataSourceId, parameters }
+            body: { parameters }
           }
         ),
         "Query execution response",
@@ -414,30 +2744,975 @@ function createQueriesModule(transport, getDataSourceId, errors = defaultSdkCore
   };
 }
 
+// src/modules/schema.ts
+function createSchemaModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const tablePath = (name) => `/api/v1/tables/${encodePathSegment(name, "table name", errors)}`;
+  const list = async (options = {}) => {
+    const params = {
+      scope: options.scope,
+      includeColumns: options.includeColumns
+    };
+    return expectSchemaTables(
+      await transport.request("/api/v1/tables", { method: "GET", params }),
+      "Schema tables response",
+      errors
+    );
+  };
+  return {
+    async createTable(tableName, columns) {
+      expectEmpty(
+        await transport.request("/api/v1/tables", {
+          method: "POST",
+          body: { tableName, columns }
+        }),
+        "Create table response",
+        errors
+      );
+    },
+    listTables: list,
+    listAppTables(options = {}) {
+      return list({
+        scope: "APP",
+        ...options.includeColumns === void 0 ? {} : { includeColumns: options.includeColumns }
+      });
+    },
+    async getTable(tableName) {
+      return expectTableDefinition(
+        await transport.request(tablePath(tableName), { method: "GET" }),
+        "Table details response",
+        errors
+      );
+    },
+    async dropTable(tableName) {
+      expectEmpty(
+        await transport.request(tablePath(tableName), { method: "DELETE" }),
+        "Drop table response",
+        errors
+      );
+    },
+    async truncateTable(tableName) {
+      expectEmpty(
+        await transport.request(`${tablePath(tableName)}/truncate`, { method: "POST" }),
+        "Truncate table response",
+        errors
+      );
+    },
+    async addColumn(tableName, column) {
+      expectEmpty(
+        await transport.request(`${tablePath(tableName)}/columns`, {
+          method: "POST",
+          body: column
+        }),
+        "Add column response",
+        errors
+      );
+    },
+    async dropColumn(tableName, columnName) {
+      expectEmpty(
+        await transport.request(
+          `${tablePath(tableName)}/columns/${encodePathSegment(columnName, "column name", errors)}`,
+          { method: "DELETE" }
+        ),
+        "Drop column response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/sql.ts
+var MAX_STATEMENTS = 20;
+function createSqlModule(transport, errors = defaultSdkCoreErrorFactory) {
+  return {
+    async executeQuery(sql, parameters = {}) {
+      return expectQueryResult(
+        await transport.request("/api/v1/sql/execute", {
+          method: "POST",
+          body: { sql, parameters }
+        }),
+        "SQL execution response",
+        errors
+      );
+    },
+    async executeDdl(statements) {
+      requireBatchSize(statements, "statements", MAX_STATEMENTS, errors);
+      return expectBatchExecution(
+        await transport.request("/api/v1/sql/ddl/execute", {
+          method: "POST",
+          body: { statements }
+        }),
+        "DDL batch response",
+        errors
+      );
+    },
+    async executeDml(statements) {
+      requireBatchSize(statements, "statements", MAX_STATEMENTS, errors);
+      return expectBatchExecution(
+        await transport.request("/api/v1/sql/dml/execute", {
+          method: "POST",
+          body: { statements }
+        }),
+        "DML batch response",
+        errors
+      );
+    },
+    async listTables(options = {}) {
+      const params = {
+        scope: options.scope,
+        includeColumns: options.includeColumns
+      };
+      return expectSchemaTables(
+        await transport.request("/api/v1/tables", { method: "GET", params }),
+        "Schema tables response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/workflows.ts
+function createWorkflowsModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const path = (id) => `/api/v1/workflows/${encodePathSegment(id, "workflow id", errors)}`;
+  const params = (options = {}) => ({
+    page: options.page,
+    size: options.size,
+    sort: options.sort
+  });
+  const executionPath = (workflowId, executionId) => `${path(workflowId)}/executions${executionId === void 0 ? "" : `/${encodePathSegment(executionId, "workflow execution id", errors)}`}`;
+  return {
+    async list(options = {}) {
+      return expectPage(
+        await transport.request("/api/v1/workflows", {
+          method: "GET",
+          params: params(options)
+        }),
+        "Workflow page response",
+        errors,
+        expectWorkflowSummary
+      );
+    },
+    async get(id) {
+      return expectWorkflowDefinition(
+        await transport.request(path(id), { method: "GET" }),
+        "Workflow response",
+        errors
+      );
+    },
+    async create(input) {
+      return expectWorkflowDefinition(
+        await transport.request("/api/v1/workflows", {
+          method: "POST",
+          body: input
+        }),
+        "Create workflow response",
+        errors
+      );
+    },
+    async update(id, input) {
+      return expectWorkflowDefinition(
+        await transport.request(path(id), { method: "PUT", body: input }),
+        "Update workflow response",
+        errors
+      );
+    },
+    async delete(id) {
+      expectEmpty(
+        await transport.request(path(id), { method: "DELETE" }),
+        "Delete workflow response",
+        errors
+      );
+    },
+    async execute(id, input = {}) {
+      return expectWorkflowExecution(
+        await transport.request(`${path(id)}/execute`, {
+          method: "POST",
+          body: { input }
+        }),
+        "Workflow execution response",
+        errors
+      );
+    },
+    async listExecutions(workflowId, options = {}) {
+      return expectPage(
+        await transport.request(executionPath(workflowId), {
+          method: "GET",
+          params: params(options)
+        }),
+        "Workflow execution page response",
+        errors,
+        expectWorkflowExecution
+      );
+    },
+    async getExecution(workflowId, executionId) {
+      return expectWorkflowExecution(
+        await transport.request(executionPath(workflowId, executionId), { method: "GET" }),
+        "Workflow execution response",
+        errors
+      );
+    },
+    async cancelExecution(workflowId, executionId) {
+      expectEmpty(
+        await transport.request(`${executionPath(workflowId, executionId)}/cancel`, {
+          method: "POST"
+        }),
+        "Cancel workflow execution response",
+        errors
+      );
+    }
+  };
+}
+
 // src/core.ts
 function createSdkCore(options) {
   const errors = options.errors ?? defaultSdkCoreErrorFactory;
+  const codeStudio = options.transports.codeStudio ?? unavailableTransport("codeStudio", errors);
+  const copilot = options.transports.copilot ?? unavailableTransport("copilot", errors);
+  const messengerTransport = options.transports.messenger ?? unavailableTransport("messenger", errors);
+  const apps = createAppsModule(codeStudio, errors);
+  const schema = createSchemaModule(options.transports.dataManager, errors);
+  const functionsAdmin = createFunctionsAdminModule(options.transports.functions, errors);
+  const agents = createAgentsModule(options.transports.functions, copilot, errors);
+  const integrationAdmin = createIntegrationAdminModule(options.transports.integration, errors);
+  const agentConnections = createAgentConnectionsModule(copilot, errors);
+  const members = createMembersModule(options.transports.auth, errors);
   return {
+    agentConnections,
+    agentCredentials: createAgentCredentialsModule(copilot, errors),
+    agents,
+    agentTasks: createAgentTasksModule(copilot, errors),
+    apps,
     auth: createAuthModule(options.transports.auth, errors),
+    context: createContextModule(
+      {
+        apps,
+        schema,
+        functionsAdmin,
+        agents,
+        integrationAdmin,
+        agentConnections,
+        getAppId: options.getAppId
+      },
+      errors
+    ),
+    customQueries: createCustomQueriesModule(options.transports.dataManager, errors),
+    dataSources: createDataSourcesModule(options.transports.dataManager, errors),
     entities: createEntitiesModule(options.transports.dataManager, errors),
     functions: createFunctionsModule(options.transports.functions, options.functions, errors),
+    functionsAdmin,
+    imports: createImportsModule(options.transports.dataManager, errors),
     integration: createIntegrationModule(options.transports.integration, errors),
-    queries: createQueriesModule(options.transports.dataManager, options.getDataSourceId, errors)
+    integrationAdmin,
+    integrationResources: createIntegrationResourcesModule(options.transports.integration, errors),
+    integrationTemplates: createIntegrationTemplatesModule(options.transports.integration, errors),
+    members,
+    messenger: createMessengerModule(messengerTransport, errors),
+    publicFunctions: createPublicFunctionsModule(options.transports.publicFunctions, errors),
+    queries: createQueriesModule(options.transports.dataManager, errors),
+    sql: createSqlModule(options.transports.dataManager, errors),
+    schema,
+    workflows: createWorkflowsModule(options.transports.functions, errors)
+  };
+}
+function unavailableTransport(name, errors) {
+  return {
+    request() {
+      return Promise.reject(errors.configuration(`The ${name} transport is not configured`));
+    }
+  };
+}
+
+// src/agentSession.ts
+var AGENT_QUEUE_LIMIT = 10;
+var CANCEL_SAFETY_MS = 1e4;
+var RECONCILE_DELAY_MS = 1e3;
+var AgentTaskTurnError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "AgentTaskTurnError";
+    this.code = code;
+  }
+};
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  return String(error);
+}
+function errorCode(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const candidate = error;
+  const code = candidate.code ?? candidate.details?.code ?? candidate.details?.error_code;
+  return typeof code === "string" ? code : void 0;
+}
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function toAgentTimelineItem(message) {
+  if (message.type === "TOOL_USE") {
+    try {
+      const payload = JSON.parse(message.content);
+      if (payload && typeof payload === "object") {
+        return {
+          id: message.id,
+          kind: "tool",
+          tool: {
+            tool: typeof payload.name === "string" ? payload.name : "",
+            ...typeof payload.toolId === "string" ? { toolId: payload.toolId } : {},
+            ...payload.input !== void 0 ? { input: payload.input } : {},
+            ...payload.content !== void 0 ? { content: payload.content } : payload.output !== void 0 ? { content: payload.output } : {},
+            phase: payload.output !== void 0 || payload.content !== void 0 ? "result" : "call"
+          },
+          at: message.createdAt
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    id: message.id,
+    kind: message.sender === "USER" ? "user" : "agent",
+    text: message.content,
+    at: message.createdAt
+  };
+}
+function createAgentTaskSessionManager(options) {
+  const sessions = /* @__PURE__ */ new Map();
+  return {
+    session(sessionOptions) {
+      if ("taskId" in sessionOptions) {
+        const current = sessions.get(sessionOptions.taskId);
+        if (current && current.status !== "closed") return current;
+      }
+      const session = new CoreAgentTaskSession(sessionOptions, {
+        ...options,
+        onTaskId: (taskId, value) => sessions.set(taskId, value),
+        onClose: (taskId, value) => {
+          if (sessions.get(taskId) === value) sessions.delete(taskId);
+        }
+      });
+      if ("taskId" in sessionOptions) sessions.set(sessionOptions.taskId, session);
+      return session;
+    }
   };
 }
+function withAgentTaskSessions(tasks, manager) {
+  return { ...tasks, session: (options) => manager.session(options) };
+}
+var CoreAgentTaskSession = class {
+  constructor(options, dependencies) {
+    this.options = options;
+    this.dependencies = dependencies;
+    this.isNewSession = "create" in options;
+    if ("taskId" in options) {
+      this._taskId = options.taskId;
+      this.openingPromise = this.openExisting();
+    } else {
+      this._status = "idle";
+    }
+  }
+  _taskId = null;
+  _task = null;
+  _status = "opening";
+  _history = [];
+  _content = "";
+  _queue = [];
+  isNewSession;
+  listeners = /* @__PURE__ */ new Map();
+  connection = null;
+  connectionAbort = null;
+  connectionPromise = null;
+  openingPromise = null;
+  createPromise = null;
+  dispatching = false;
+  recoveryUsed = false;
+  recoveryPromise = null;
+  recoveryGeneration = 0;
+  recoveredTerminalReason;
+  cancelTimer = null;
+  queueSequence = 0;
+  activeWaiter;
+  turnBaselineIds = /* @__PURE__ */ new Set();
+  get taskId() {
+    return this._taskId;
+  }
+  get task() {
+    return this._task;
+  }
+  get isNew() {
+    return this.isNewSession;
+  }
+  get status() {
+    return this._status;
+  }
+  get history() {
+    return [...this._history];
+  }
+  get content() {
+    return this._content;
+  }
+  get queue() {
+    return this._queue.map((item) => ({
+      id: item.id,
+      text: item.text,
+      createdAt: item.createdAt,
+      ...item.agentType ? { agentType: item.agentType } : {},
+      ...item.reasoningEffort ? { reasoningEffort: item.reasoningEffort } : {}
+    }));
+  }
+  send(prompt, options = {}) {
+    this.requireOpen();
+    if (!prompt.trim()) return;
+    if (this.isBusy()) {
+      this.enqueue(prompt, options);
+      return;
+    }
+    this.startDispatch(prompt, options);
+  }
+  sendAndWait(prompt, options = {}) {
+    this.requireOpen();
+    if (!prompt.trim()) return Promise.reject(new Error("Agent prompt must not be blank."));
+    const waiter = this.createWaiter(options);
+    if (waiter.settled) return waiter.promise;
+    const sendOptions = {
+      ...options.agentType ? { agentType: options.agentType } : {},
+      ...options.reasoningEffort ? { reasoningEffort: options.reasoningEffort } : {}
+    };
+    if (this.isBusy()) {
+      const queueId = this.enqueue(prompt, sendOptions, waiter);
+      if (queueId) waiter.queueId = queueId;
+      return waiter.promise;
+    }
+    this.startDispatch(prompt, sendOptions, waiter);
+    return waiter.promise;
+  }
+  async cancel() {
+    if (this._status !== "streaming" && this._status !== "cancelled") return;
+    try {
+      await this.sendInput({ type: "interrupt" });
+      this.setStatus("cancelled");
+      this.emit("cancelled", {});
+      if (this.cancelTimer) clearTimeout(this.cancelTimer);
+      this.cancelTimer = setTimeout(() => {
+        this.cancelTimer = null;
+        if (this._status === "cancelled") {
+          const error = new AgentTaskTurnError(
+            "Agent turn cancellation was not acknowledged before the safety timeout."
+          );
+          this.emit("error", { error: error.message });
+          this.failTurn(error);
+        }
+      }, CANCEL_SAFETY_MS);
+    } catch (error) {
+      this.emitError("Failed to cancel Agent task", error);
+      throw error;
+    }
+  }
+  respondApproval(approved) {
+    void this.sendInput({ type: "approval_response", approved }).catch((error) => {
+      this.emitError("Failed to answer Agent approval", error);
+    });
+  }
+  async loadHistory(options = {}) {
+    if (!this._taskId) return [];
+    const page = await this.dependencies.tasks.listMessages(this._taskId, {
+      ...options.limit !== void 0 ? { size: options.limit } : {},
+      sort: "createdAt,desc"
+    });
+    this._history = [...page.content].reverse().map(toAgentTimelineItem);
+    const history = this.history;
+    this.emit("historyLoaded", { history });
+    return history;
+  }
+  editQueueItem(id, text) {
+    if (!text.trim()) {
+      this.removeQueueItem(id);
+      return;
+    }
+    this._queue = this._queue.map((item) => item.id === id ? { ...item, text } : item);
+    this.emitQueue();
+  }
+  removeQueueItem(id) {
+    const removed = this._queue.find((item) => item.id === id);
+    this._queue = this._queue.filter((item) => item.id !== id);
+    removed?.waiter?.reject(new Error("Queued Agent prompt was removed."));
+    this.emitQueue();
+  }
+  clearQueue() {
+    if (!this._queue.length) return;
+    const removed = this._queue;
+    this._queue = [];
+    for (const item of removed) item.waiter?.reject(new Error("Agent prompt queue was cleared."));
+    this.emitQueue();
+  }
+  on(event, handler) {
+    let listeners = this.listeners.get(event);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.listeners.set(event, listeners);
+    }
+    const callback = handler;
+    listeners.add(callback);
+    return () => listeners?.delete(callback);
+  }
+  close() {
+    if (this._status === "closed") return;
+    this.setStatus("closed");
+    if (this.cancelTimer) clearTimeout(this.cancelTimer);
+    this.cancelTimer = null;
+    this.connectionAbort?.abort();
+    this.connectionAbort = null;
+    this.connection?.close();
+    this.connection = null;
+    this.recoveryGeneration += 1;
+    const closedError = new Error("Agent task session is closed.");
+    this.activeWaiter?.reject(closedError);
+    this.activeWaiter = void 0;
+    for (const item of this._queue) item.waiter?.reject(closedError);
+    this._queue = [];
+    if (this._taskId) this.dependencies.onClose(this._taskId, this);
+    for (const listeners of this.listeners.values()) listeners.clear();
+  }
+  async openExisting() {
+    try {
+      this._task = await this.dependencies.tasks.get(this._taskId);
+      if (this.isClosed()) return false;
+      await this.loadHistory();
+      if (this.isClosed()) return false;
+      await this.ensureChannel();
+      if (this.isClosed()) return false;
+      this.setStatus("idle");
+      return true;
+    } catch (error) {
+      if (this.isClosed()) return false;
+      this.emitError("Failed to open Agent task", error);
+      this.setStatus("error");
+      return false;
+    }
+  }
+  startDispatch(prompt, options, waiter) {
+    this.dispatching = true;
+    void this.dispatchSend(prompt, options, waiter).catch((error) => {
+      waiter?.reject(error);
+      this.emitError("Failed to send Agent prompt", error);
+      if (this._status === "streaming") this.setStatus("idle");
+      this.flushQueue();
+    }).finally(() => {
+      this.dispatching = false;
+      if (this._status === "idle") this.flushQueue();
+    });
+  }
+  async dispatchSend(prompt, options, waiter) {
+    if (this.openingPromise && !await this.openingPromise) {
+      throw new Error("Agent task session could not be opened.");
+    }
+    if (this.isClosed() || waiter?.settled) return;
+    await this.ensureTask();
+    if (this.isClosed() || waiter?.settled) return;
+    await this.ensureChannel();
+    if (this.isClosed() || waiter?.settled) return;
+    await this.captureTurnBaseline();
+    this._content = "";
+    this.recoveryUsed = false;
+    this.recoveredTerminalReason = void 0;
+    this.recoveryGeneration += 1;
+    this.activeWaiter = waiter;
+    this.setStatus("streaming");
+    this.emit("turnStart", {});
+    await this.sendInput({
+      type: "message",
+      content: prompt,
+      ...options.agentType ? { agentType: options.agentType } : {},
+      ...options.reasoningEffort ? { reasoningEffort: options.reasoningEffort } : {}
+    });
+  }
+  async ensureTask() {
+    if (this._taskId) return;
+    if (!("create" in this.options)) throw new Error("Agent task session has no task.");
+    const createOptions = this.options;
+    if (this.createPromise) return this.createPromise;
+    this.createPromise = (async () => {
+      const task = await this.dependencies.tasks.create({
+        agentType: createOptions.agentType,
+        ...createOptions.title ? { title: createOptions.title } : {},
+        ...createOptions.agentId ? { agentId: createOptions.agentId } : {},
+        ...createOptions.reasoningEffort ? { reasoningEffort: createOptions.reasoningEffort } : {},
+        ...createOptions.userId ? { userId: createOptions.userId } : {}
+      });
+      this._task = task;
+      this._taskId = task.id;
+      this.dependencies.onTaskId(task.id, this);
+      this.emit("taskCreated", { task });
+    })().finally(() => {
+      this.createPromise = null;
+    });
+    return this.createPromise;
+  }
+  ensureChannel() {
+    if (this.connection) return Promise.resolve();
+    if (this.connectionPromise) return this.connectionPromise;
+    if (!this._taskId) return Promise.reject(new Error("Agent task has not been created."));
+    const abort = new AbortController();
+    this.connectionAbort = abort;
+    this.connectionPromise = this.dependencies.eventSource.open(
+      this._taskId,
+      {
+        onEvent: (event) => this.handleEvent(event),
+        onDisconnect: (error) => this.handleDisconnect(error)
+      },
+      abort.signal,
+      this.options.transport
+    ).then((connection) => {
+      if (this.isClosed() || this._status === "error") {
+        connection.close();
+        return;
+      }
+      this.connection = connection;
+    }).finally(() => {
+      this.connectionPromise = null;
+    });
+    return this.connectionPromise;
+  }
+  handleDisconnect(error) {
+    this.connection = null;
+    this.connectionAbort = null;
+    if (this.isClosed()) return;
+    if (this._status !== "streaming" && this._status !== "cancelled") return;
+    if (this.recoveryUsed) {
+      const disconnectError = new Error("Agent live channel disconnected after one recovery.");
+      this.failLiveChannel(error ?? disconnectError, disconnectError);
+      return;
+    }
+    this.recoveryUsed = true;
+    const generation = ++this.recoveryGeneration;
+    this.recoveryPromise = this.recoverTurn(generation).finally(() => {
+      this.recoveryPromise = null;
+    });
+  }
+  async recoverTurn(generation) {
+    try {
+      await this.ensureChannel();
+      while (generation === this.recoveryGeneration && !this.isClosed() && (this._status === "streaming" || this._status === "cancelled")) {
+        if (await this.reconcilePersistedTurn(this.recoveredTerminalReason ?? "reconciled")) {
+          return;
+        }
+        if (this.activeWaiter?.settled) return;
+        await delay(RECONCILE_DELAY_MS);
+      }
+    } catch (error) {
+      if (this.isClosed()) return;
+      const recoveryError = error instanceof Error ? error : new Error(errorMessage(error));
+      this.failLiveChannel(error, recoveryError);
+    }
+  }
+  async captureTurnBaseline() {
+    if (!this._taskId) return;
+    const page = await this.dependencies.tasks.listMessages(this._taskId, {
+      size: 100,
+      sort: "createdAt,desc"
+    });
+    this.turnBaselineIds = new Set(page.content.map((message) => message.id));
+  }
+  async reconcilePersistedTurn(reason) {
+    if (!this._taskId) return false;
+    const page = await this.dependencies.tasks.listMessages(this._taskId, {
+      size: 100,
+      sort: "createdAt,desc"
+    });
+    this._history = [...page.content].reverse().map(toAgentTimelineItem);
+    this.emit("historyLoaded", { history: this.history });
+    const recovered = page.content.find(
+      (message) => !this.turnBaselineIds.has(message.id) && message.sender !== "USER" && message.type !== "TOOL_USE"
+    );
+    if (!recovered) return false;
+    if (recovered.type === "ERROR") {
+      const error = new AgentTaskTurnError(recovered.content);
+      this.emit("error", { error: error.message });
+      this.failTurn(error);
+      return true;
+    }
+    this._content = recovered.content;
+    this.finishTurn(reason);
+    return true;
+  }
+  sendInput(input) {
+    if (!this._taskId) return Promise.reject(new Error("Agent task has not been created."));
+    return this.dependencies.tasks.sendInput(this._taskId, input);
+  }
+  handleEvent(event) {
+    this.emit("raw", event);
+    const payload = asObject(event.payload);
+    switch (event.type) {
+      case "textDelta":
+        this.consumeDelta(payload, "text");
+        break;
+      case "thinking":
+        this.consumeDelta(payload, "thinking");
+        break;
+      case "toolCall":
+        this.emitTool(payload, "call", event.timestamp);
+        break;
+      case "toolResult":
+        this.emitTool(payload, "result", event.timestamp);
+        break;
+      case "workspace":
+        this.emit("workspace", { payload: event.payload, timestamp: event.timestamp });
+        break;
+      case "stepFinish": {
+        const reason = typeof payload?.reason === "string" ? payload.reason : "unknown";
+        if (reason === "stop" || reason === "endTurn") {
+          if (this.recoveryUsed) {
+            this.recoveredTerminalReason = reason;
+            if (!this.recoveryPromise) {
+              const generation = this.recoveryGeneration;
+              this.recoveryPromise = this.recoverTurn(generation).finally(() => {
+                this.recoveryPromise = null;
+              });
+            }
+          } else {
+            this.finishTurn(reason);
+          }
+        }
+        break;
+      }
+      case "error": {
+        const code = typeof payload?.code === "string" ? payload.code : void 0;
+        const message = typeof payload?.message === "string" ? payload.message : "Agent returned an error.";
+        this.emit("error", { ...code ? { code } : {}, error: message });
+        if (this._status === "streaming" || this._status === "cancelled") {
+          this.failTurn(new AgentTaskTurnError(message, code));
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  consumeDelta(payload, kind) {
+    const text = typeof payload?.text === "string" ? payload.text : "";
+    if (this._status !== "streaming" && this._status !== "cancelled") {
+      this.setStatus("streaming");
+      this.emit("turnStart", {});
+    }
+    if (kind === "text") this._content += text;
+    this.emit("delta", { delta: text, kind });
+  }
+  emitTool(payload, phase, timestamp) {
+    this.emit("tool", {
+      tool: typeof payload?.name === "string" ? payload.name : "",
+      phase,
+      timestamp,
+      ...typeof payload?.toolId === "string" ? { toolId: payload.toolId } : {},
+      ...phase === "call" && payload?.input !== void 0 ? { input: payload.input } : {},
+      ...phase === "result" ? { content: payload?.content ?? payload?.output } : {}
+    });
+  }
+  finishTurn(reason) {
+    if (this._status !== "streaming" && this._status !== "cancelled") return;
+    if (this.cancelTimer) clearTimeout(this.cancelTimer);
+    this.cancelTimer = null;
+    this.recoveryGeneration += 1;
+    const task = this._task;
+    if (!task) {
+      const error = new Error("Agent turn ended before task metadata was available.");
+      this.activeWaiter?.reject(error);
+      this.activeWaiter = void 0;
+      this.emitError("Failed to finish Agent turn", error);
+      this.setStatus("error");
+      return;
+    }
+    const result = { task, content: this._content, reason };
+    this.emit("turnEnd", result);
+    this.activeWaiter?.resolve(result);
+    this.activeWaiter = void 0;
+    this.setStatus("idle");
+    this.flushQueue();
+  }
+  failTurn(error) {
+    if (this.cancelTimer) clearTimeout(this.cancelTimer);
+    this.cancelTimer = null;
+    this.recoveryGeneration += 1;
+    this.activeWaiter?.reject(error);
+    this.activeWaiter = void 0;
+    this.setStatus("idle");
+    this.flushQueue();
+  }
+  failLiveChannel(observed, waiterError) {
+    this.recoveryGeneration += 1;
+    this.emitError("Agent live channel failed", observed);
+    this.activeWaiter?.reject(waiterError);
+    this.activeWaiter = void 0;
+    for (const item of this._queue) item.waiter?.reject(waiterError);
+    this._queue = [];
+    this.emitQueue();
+    this.setStatus("error");
+  }
+  enqueue(text, options, waiter) {
+    if (this._queue.length >= AGENT_QUEUE_LIMIT) {
+      const error = new Error(`Agent message queue is full (maximum ${AGENT_QUEUE_LIMIT}).`);
+      waiter?.reject(error);
+      this.emit("error", { error: error.message });
+      return void 0;
+    }
+    const id = `q-${++this.queueSequence}`;
+    this._queue = [
+      ...this._queue,
+      { id, text, createdAt: Date.now(), ...options, ...waiter ? { waiter } : {} }
+    ];
+    this.emitQueue();
+    return id;
+  }
+  flushQueue() {
+    if (this.isBusy()) return;
+    let next = this._queue[0];
+    while (next?.waiter?.settled) {
+      this._queue = this._queue.slice(1);
+      next = this._queue[0];
+    }
+    if (!next) {
+      this.emitQueue();
+      return;
+    }
+    this._queue = this._queue.slice(1);
+    this.emitQueue();
+    this.startDispatch(
+      next.text,
+      {
+        ...next.agentType ? { agentType: next.agentType } : {},
+        ...next.reasoningEffort ? { reasoningEffort: next.reasoningEffort } : {}
+      },
+      next.waiter
+    );
+  }
+  createWaiter(options) {
+    let resolvePromise;
+    let rejectPromise;
+    let timer;
+    let abortListener;
+    const waiter = {
+      promise: new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+      }),
+      settled: false,
+      resolve: (result) => {
+        if (waiter.settled) return;
+        waiter.settled = true;
+        waiter.cleanup();
+        resolvePromise(result);
+      },
+      reject: (error) => {
+        if (waiter.settled) return;
+        waiter.settled = true;
+        waiter.cleanup();
+        if (waiter.queueId) this.removeQueuedWaiter(waiter.queueId);
+        rejectPromise(error);
+      },
+      cleanup: () => {
+        if (timer) clearTimeout(timer);
+        if (abortListener) options.signal?.removeEventListener("abort", abortListener);
+      }
+    };
+    if (options.timeoutMs !== void 0) {
+      if (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0) {
+        waiter.reject(new Error("Agent turn timeoutMs must be a positive number."));
+        return waiter;
+      }
+      timer = setTimeout(
+        () => waiter.reject(new Error(`Agent turn timed out after ${options.timeoutMs} ms.`)),
+        options.timeoutMs
+      );
+    }
+    if (options.signal) {
+      abortListener = () => waiter.reject(options.signal?.reason ?? new Error("Agent turn aborted."));
+      if (options.signal.aborted) abortListener();
+      else options.signal.addEventListener("abort", abortListener, { once: true });
+    }
+    return waiter;
+  }
+  removeQueuedWaiter(id) {
+    const size = this._queue.length;
+    this._queue = this._queue.filter((item) => item.id !== id);
+    if (this._queue.length !== size) this.emitQueue();
+  }
+  emitQueue() {
+    this.emit("queueChange", { queue: this.queue });
+  }
+  emitError(prefix, error) {
+    const code = errorCode(error);
+    this.emit("error", {
+      ...code ? { code } : {},
+      error: `${prefix}: ${errorMessage(error)}`
+    });
+  }
+  setStatus(status) {
+    if (this._status === status) return;
+    this._status = status;
+    this.emit("statusChange", { status });
+  }
+  requireOpen() {
+    if (this.isClosed()) throw new Error("Agent task session is closed.");
+  }
+  isClosed() {
+    return this._status === "closed";
+  }
+  isBusy() {
+    return this.dispatching || this._status === "streaming" || this._status === "cancelled";
+  }
+  emit(event, payload) {
+    const listeners = this.listeners.get(event);
+    for (const listener of listeners ?? []) {
+      try {
+        listener(payload);
+      } catch {
+      }
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AgentTaskTurnError,
   SdkCoreConfigurationError,
   SdkCoreResponseError,
+  createAgentConnectionsModule,
+  createAgentCredentialsModule,
+  createAgentTaskSessionManager,
+  createAgentTasksModule,
+  createAgentsModule,
+  createAppsModule,
   createAuthModule,
+  createContextModule,
+  createCustomQueriesModule,
+  createDataSourcesModule,
   createEntitiesModule,
+  createFunctionsAdminModule,
   createFunctionsModule,
+  createImportsModule,
+  createIntegrationAdminModule,
   createIntegrationModule,
+  createIntegrationResourcesModule,
+  createIntegrationTemplatesModule,
+  createMembersModule,
+  createMessengerModule,
+  createPublicFunctionsModule,
   createQueriesModule,
+  createSchemaModule,
   createSdkCore,
+  createSqlModule,
+  createWorkflowsModule,
   defaultSdkCoreErrorFactory,
   encodePathSegment,
   expectEmpty,
+  expectLegacyPage,
+  expectNullableObject,
   expectObject,
-  expectObjectArray
+  expectObjectArray,
+  expectPage,
+  expectStringArray,
+  toAgentTimelineItem,
+  withAgentTaskSessions
 });