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

package/dist/index.d.cts

@@ -12,8 +12,9 @@ declare class SdkCoreResponseError extends Error {
 }
 declare const defaultSdkCoreErrorFactory: SdkCoreErrorFactory;
 
-type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
-type QueryParamValue = string | number | boolean | undefined;
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+type QueryParamPrimitive = string | number | boolean;
+type QueryParamValue = QueryParamPrimitive | readonly QueryParamPrimitive[] | undefined;
 interface TransportRequestOptions {
     method?: HttpMethod;
     body?: unknown;
@@ -24,17 +25,24 @@ interface Transport {
     request<T>(path: string, options?: TransportRequestOptions): Promise<T>;
 }
 
-interface Plan {
+interface PlanPrice {
+    currency: string;
+    amountMinorUnits: number;
+    interval: string;
+}
+interface UserPlan {
     id: string;
+    code: string;
     name: string;
-    [key: string]: unknown;
+    maxUsers: number;
+    prices: PlanPrice[];
 }
 interface Tenant {
     id: string;
     shortId: string;
     legacyId: number | null;
     slug: string;
-    plan: Plan;
+    clusterType: "SHARED" | "DEDICATED";
     name: string;
     description: string | null;
     hexColor: string | null;
@@ -49,7 +57,11 @@ interface User {
     name: string;
     email: string;
     imageUrl: string | null;
+    /** Plan selected for the authenticated user in the current tenant. */
+    planId: string;
     onboardingCompleted: boolean;
+    /** User language preference returned by IAM. */
+    language: string;
 }
 interface EntityListOptions {
     sort?: string;
@@ -58,8 +70,8 @@ interface EntityListOptions {
     fields?: string[];
 }
 interface EntityTable<T = Record<string, unknown>> {
-    list(sortOrOptions?: string | EntityListOptions, limit?: number, skip?: number, fields?: string[]): Promise<T[]>;
-    filter(query: Record<string, unknown>, sort?: string, limit?: number, skip?: number, fields?: string[]): Promise<T[]>;
+    list(sortOrOptions?: string | EntityListOptions, limit?: number, skip?: number, fields?: string[]): Promise<EntityListResponse<T>>;
+    filter(query: Record<string, unknown>, sort?: string, limit?: number, skip?: number, fields?: string[]): Promise<EntityListResponse<T>>;
     get(id: string | number): Promise<T>;
     create(data: Partial<T>): Promise<T>;
     bulkCreate(data: Partial<T>[]): Promise<T[]>;
@@ -69,11 +81,26 @@ interface EntityTable<T = Record<string, unknown>> {
         deleted: number;
     }>;
 }
+interface EntityListResponse<T> {
+    /** Records in the requested window. */
+    data: T[];
+    /** Effective maximum number of records returned. */
+    limit: number;
+    /** Effective number of records skipped. */
+    skip: number;
+    /** Total records matching the request. */
+    total: number;
+    /** Whether another window is available after this one. */
+    hasMore: boolean;
+}
 interface QueryResult {
     rows: Record<string, unknown>[];
     affectedRows?: number | null;
     durationMs: number;
 }
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
 interface FunctionExecution {
     id: string;
     functionId: string;
@@ -86,7 +113,7 @@ interface FunctionExecution {
     durationMs: number | null;
     startedAt: string | null;
     finishedAt: string | null;
-    createdAt: string;
+    createdAt: string | null;
 }
 interface ProxyInput {
     method: string;
@@ -102,12 +129,1337 @@ interface ProxyResult {
     durationMs: number;
     executionId: string;
 }
+interface DdlStatement {
+    /** One DDL command. Batch execution is ordered and stops after the first failure. */
+    sql: string;
+}
+interface DmlStatement {
+    /** One DML command using named parameters instead of interpolated values. */
+    sql: string;
+    /** Values bound by the database driver. Defaults to an empty object. */
+    parameters?: Record<string, unknown>;
+}
+interface BatchStatementResult {
+    index: number;
+    /** Reported for DML statements only. The DDL path omits the field entirely. */
+    affectedRows?: number;
+    durationMs: number;
+}
+interface BatchExecution {
+    results: BatchStatementResult[];
+    executedCount: number;
+    totalDurationMs: number;
+}
+type SchemaScope = "APP" | "SHARED";
+interface ListTablesOptions {
+    /** APP, SHARED, or omission for both scopes. */
+    scope?: SchemaScope;
+    /** Includes column and foreign-key metadata. Defaults to false. */
+    includeColumns?: boolean;
+}
+interface TableColumn {
+    name: string;
+    type: string;
+    primaryKey: boolean;
+    nullable: boolean;
+    defaultValue: string | null;
+}
+interface TableForeignKey {
+    columns: string[];
+    referencedTable: string;
+    referencedColumns: string[];
+}
+interface TableDefinition {
+    tableName: string;
+    columns: TableColumn[];
+    foreignKeys: TableForeignKey[];
+}
+interface SchemaTables {
+    schema: string;
+    tables: TableDefinition[];
+}
+/** Core authoring APIs create and mutate EXTERNAL Data Sources only. */
+type DataSourceInstanceType = "MITRA_SHARED" | "MITRA_DEDICATED" | "EXTERNAL";
+type DataSourceDbType = "POSTGRES" | "MYSQL" | "SQLSERVER" | "ORACLE";
+interface ConnectionConfig {
+    host: string;
+    port: number;
+    schema?: string;
+    databaseName: string;
+    username: string;
+    /** Write-only. The service never returns it, and an update that omits it keeps the stored one. */
+    credential?: string;
+    /** Maximum pool size. Defaults to 10. */
+    maxPoolSize?: number;
+    /** Connection acquisition timeout in milliseconds. Defaults to 30000. */
+    connectionTimeoutMs?: number;
+    /** Idle connection timeout in milliseconds. Defaults to 600000. */
+    idleTimeoutMs?: number;
+    /** Minimum idle connections. Defaults to 2. */
+    minimumIdle?: number;
+    /** Maximum connection lifetime in milliseconds. Defaults to 1800000. */
+    maxLifetimeMs?: number;
+    additionalParams?: Record<string, string>;
+}
+interface DataSourceCreateInput {
+    legacyId?: number;
+    name: string;
+    instanceType: DataSourceInstanceType;
+    dbType: DataSourceDbType;
+    writeConnectionConfig: ConnectionConfig;
+    readConnectionConfig?: ConnectionConfig;
+}
+interface DataSourceUpdateInput {
+    dataSourceId: string;
+    name: string;
+    instanceType: DataSourceInstanceType;
+    dbType: DataSourceDbType;
+    writeConnectionConfig: ConnectionConfig;
+    readConnectionConfig?: ConnectionConfig;
+}
+interface DataSourceBulkItemResult {
+    index: number;
+    success: boolean;
+    dataSourceId: string | null;
+    errorCode: string | null;
+    message: string | null;
+}
+interface DataSourceBulkResult {
+    results: DataSourceBulkItemResult[];
+    processedCount: number;
+    succeededCount: number;
+    failedCount: number;
+}
+interface DataSourceDefinition {
+    id: string;
+    /** Legacy identifier when the Data Source was migrated from the previous platform. */
+    legacyId: number | null;
+    /** Owning app, or null for a tenant-level Data Source. */
+    appId: string | null;
+    name: string;
+    instanceType: DataSourceInstanceType;
+    dbType: DataSourceDbType;
+    /** Write connection metadata. Stored credentials are always returned as null. */
+    writeConnectionConfig: ConnectionConfigResponse;
+    /** Read connection metadata when a separate read connection is configured. */
+    readConnectionConfig: ConnectionConfigResponse | null;
+    /** Result of the most recent connection check. */
+    connectionStatus: "CONNECTED" | "ERROR" | null;
+    lastCheckedAt: string | null;
+    /** Latest measured storage usage, or null when no measurement exists. */
+    storageQuota: {
+        status: "NORMAL" | "WATCH" | "BLOCKED" | null;
+        usedBytes: number | null;
+        limitBytes: number | null;
+        measuredAt: string | null;
+        measurementVersion: number | null;
+    } | null;
+}
+interface ConnectionConfigResponse {
+    host: string | null;
+    port: number | null;
+    schema: string | null;
+    databaseName: string | null;
+    username: string | null;
+    /** Write-only in requests. Producer responses serialize it as null. */
+    credential: null;
+    maxPoolSize: number | null;
+    connectionTimeoutMs: number | null;
+    idleTimeoutMs: number | null;
+    minimumIdle: number | null;
+    maxLifetimeMs: number | null;
+    additionalParams: Record<string, string> | null;
+}
+type FunctionRuntime = "JAVASCRIPT" | "PYTHON" | "SQL" | "API";
+/**
+ * Creates a Function and optionally composes its schedule in the same operation.
+ *
+ * `cronExpression`, `cronInputJson`, and `cronEnabled` are one scheduling unit. Omit all three to
+ * create no schedule. Supplying any one requires a non-blank `cronExpression`; the new schedule is
+ * evaluated in UTC and starts enabled unless `cronEnabled` is false.
+ */
+interface FunctionCreateInput {
+    legacyId?: number;
+    name: string;
+    description?: string;
+    runtime: FunctionRuntime;
+    /** Required for the SQL runtime and rejected for every other runtime. */
+    dataSourceId?: string;
+    code: string;
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    secrets?: string[];
+    /** Optional six-field schedule expression including seconds. */
+    cronExpression?: string;
+    /** Input supplied to scheduled executions. Requires `cronExpression` on create. */
+    cronInputJson?: Record<string, JsonValue>;
+    /** Initial schedule state. Defaults to true and requires `cronExpression` on create. */
+    cronEnabled?: boolean;
+}
+interface FunctionUpdateInput {
+    name: string;
+    description?: string;
+    code: string;
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    secrets?: string[];
+}
+/**
+ * Partial Function update used by PATCH endpoints.
+ *
+ * Omitted and null fields preserve the stored value. Empty strings, objects, and arrays are sent
+ * as explicit replacements when the service accepts them.
+ *
+ * `cronExpression`, `cronInputJson`, and `cronEnabled` are one composed scheduling unit. A blank
+ * expression removes the schedule. A non-blank expression creates a missing schedule in UTC;
+ * otherwise patching a missing schedule fails. An empty input object clears the scheduled input,
+ * and `cronEnabled` explicitly pauses or resumes the schedule.
+ */
+interface FunctionPatchInput {
+    /** New name, 3 to 255 characters. */
+    name?: string | null;
+    /** New description, at most 1000 characters. */
+    description?: string | null;
+    /** New non-blank source code. */
+    code?: string | null;
+    /** Complete replacement input schema. */
+    inputSchema?: Record<string, unknown> | null;
+    /** Complete replacement output schema. */
+    outputSchema?: Record<string, unknown> | null;
+    /** Complete replacement secret-name list. */
+    secrets?: string[] | null;
+    /** Six-field schedule expression. Blank removes the schedule; null or omission preserves it. */
+    cronExpression?: string | null;
+    /** Complete scheduled-input replacement. Null or omission preserves it; an empty object clears it. */
+    cronInputJson?: Record<string, JsonValue> | null;
+    /** Enables or pauses the schedule. Null or omission preserves its state. */
+    cronEnabled?: boolean | null;
+}
+/** Bulk create does not compose schedule changes; use the single-Function create endpoint. */
+type FunctionBulkCreateInput = Omit<FunctionCreateInput, "cronExpression" | "cronInputJson" | "cronEnabled">;
+/** Bulk patch does not compose schedule changes; use the single-Function patch endpoint. */
+type FunctionBulkPatchInput = Omit<FunctionPatchInput, "cronExpression" | "cronInputJson" | "cronEnabled">;
+interface FunctionBulkUpdateItem {
+    id: string;
+    update: FunctionUpdateInput;
+}
+interface FunctionBulkPatchItem {
+    id: string;
+    update: FunctionBulkPatchInput;
+}
+type FunctionBulkDeleteInput = {
+    ids: string[];
+    allInApp?: undefined;
+} | {
+    allInApp: true;
+    ids?: undefined;
+};
+interface FunctionBulkDeleteResult {
+    deleted: string[];
+    notFound: string[];
+    deletedCount: number;
+}
+interface FunctionVersion {
+    id: string;
+    functionId: string;
+    status: string;
+    code: string;
+    inputSchema: Record<string, unknown> | null;
+    outputSchema: Record<string, unknown> | null;
+    secrets: string[] | null;
+    createdAt: string;
+}
+/**
+ * Complete Function detail. On Function get responses, the three cron fields are populated only
+ * with `SCHEDULE_READ`; all three are also null when no schedule exists.
+ */
+interface FunctionDefinition {
+    id: string;
+    tenantId: string;
+    appId: string | null;
+    legacyId: number | null;
+    name: string;
+    description: string | null;
+    runtime: string;
+    dataSourceId: string | null;
+    visibility: string;
+    currentVersion: FunctionVersion | null;
+    cronExpression: string | null;
+    cronInputJson: Record<string, JsonValue> | null;
+    cronEnabled: boolean | null;
+    createdAt: string | null;
+    updatedAt: string;
+}
+interface TemplateConfigCreateInput {
+    /** Integration template UUID. */
+    templateId: string;
+    /** App-unique alias used by proxy execution. */
+    alias: string;
+    legacyId?: number;
+    /** Complete credential and configuration map. Values are write-only. */
+    values: Record<string, JsonValue>;
+}
+interface TemplateConfigUpdateInput {
+    configId: string;
+    alias: string;
+    /** Omitting it keeps the stored configuration. Sending it replaces the whole map. */
+    values?: Record<string, JsonValue>;
+}
+interface TemplateConfigBulkItemResult {
+    index: number;
+    success: boolean;
+    configId: string | null;
+    errorCode: string | null;
+    message: string | null;
+}
+interface TemplateConfigBulkResult {
+    results: TemplateConfigBulkItemResult[];
+    processedCount: number;
+    succeededCount: number;
+    failedCount: number;
+}
+interface TemplateConfigSummary {
+    id: string;
+    appId: string | null;
+    legacyId: number | null;
+    templateId: string;
+    alias: string;
+    status: IntegrationConnectionStatus | null;
+    lastCheckedAt: string | null;
+}
+interface TemplateConfig extends TemplateConfigSummary {
+    tenantId: string;
+    config: Record<string, JsonValue>;
+    lastCheckMessage: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+type TemplateConfigPage = LegacyPage<TemplateConfigSummary>;
+interface ListTemplateConfigsOptions {
+    page?: number;
+    size?: number;
+    sort?: string;
+}
+interface TestCredentialsInput {
+    templateId: string;
+    values: Record<string, JsonValue>;
+}
+interface ConnectionTestResult {
+    status: IntegrationConnectionStatus;
+    durationMs: number;
+    checkedAt: string;
+    message: string | null;
+}
+interface AppMember {
+    userId: string;
+    name: string;
+    email: string;
+    accessLevel: string;
+    accessSource: string;
+}
+interface InviteAppUserInput {
+    /** Email receiving app access. */
+    email: string;
+    /** Display name used only if a new Mitra identity must be created. */
+    name?: string;
+}
+interface BulkUnsubscribeResult {
+    revoked: string[];
+    notFound: string[];
+    revokedCount: number;
+}
+/** Stable Spring page returned by services using VIA_DTO serialization. */
+interface Page<T> {
+    content: T[];
+    /** Pagination metadata nested by Spring's stable DTO representation. */
+    page: {
+        size: number;
+        totalElements: number;
+        totalPages: number;
+        number: number;
+    };
+}
+/** Legacy Spring PageImpl shape still returned by mitra-integration. */
+interface LegacyPage<T> {
+    content: T[];
+    totalElements: number;
+    totalPages?: number;
+    size?: number;
+    number?: number;
+    [key: string]: unknown;
+}
+/** Common zero-based pagination accepted by builder list methods. */
+interface PageOptions {
+    /** Zero-based page number. Defaults to 0 in the service. */
+    page?: number;
+    /** Items per page. Service defaults vary by resource; the maximum is 100 unless documented. */
+    size?: number;
+    /** Spring sort expression, for example `createdAt,desc`. */
+    sort?: string;
+}
+type AppColor = {
+    type: "SOLID";
+    hex: string;
+} | {
+    type: "GRADIENT";
+    startHex: string;
+    endHex: string;
+};
+type AppVersionStatus = "DRAFT" | "PUBLISHED";
+interface AppListOptions extends PageOptions {
+    /** Optional case-insensitive app name search. Blank values are ignored by the service. */
+    search?: string;
+    /** Filters apps by the status of their current version. */
+    version?: AppVersionStatus;
+    /** Filters apps by their lowercase brand identifier. Blank values are ignored. */
+    brand?: string;
+}
+interface AppGetOptions {
+    /** Returns the selected DRAFT or PUBLISHED version instead of the default current version. */
+    version?: AppVersionStatus;
+}
+interface AppPublishOptions {
+    /** Updates external access as part of the publish request when supplied. */
+    externalAccess?: boolean;
+}
+interface AppCreateInput {
+    /** Optional positive identifier preserved while migrating a legacy app. */
+    legacyId?: number;
+    /** App name, at most 100 characters. */
+    name: string;
+    /** Optional context shown to builders and coding agents. */
+    description?: string;
+    /** Solid or gradient presentation color. Defaults to solid `#7839EE`. */
+    color?: AppColor;
+    /** Optional icon identifier, at most 50 characters. Blank values are stored as null. */
+    icon?: string;
+    /** Optional data source UUID bound to the app. */
+    dataSourceId?: string;
+    /** Optional IAM app plan UUID. */
+    planId?: string;
+    /** Initial file template. Defaults to `react-vite-shadcn`. */
+    template?: string;
+    /** Optional vanity subdomain, 3 to 51 lowercase alphanumeric or hyphen characters. */
+    subdomain?: string;
+    /** Optional lowercase brand identifier, at most 32 characters. */
+    brand?: string;
+    /** Whether users may sign up through this app. Defaults to true. */
+    allowSignup?: boolean;
+}
+interface AppUpdateInput {
+    /** New name, at most 100 characters. Omission preserves the current value. */
+    name?: string;
+    /** New description, at most 1000 characters. Omission preserves the current value. */
+    description?: string;
+    /** New solid or gradient color. Omission preserves the current value. */
+    color?: AppColor;
+    /** New icon identifier, at most 50 characters. Omission preserves the current value. */
+    icon?: string;
+    /** Whether users may sign up through this app. Omission preserves the current value. */
+    allowSignup?: boolean;
+}
+interface AppDomain {
+    hostname: string;
+    kind: "PLATFORM" | "CUSTOM";
+    status: "ACTIVE" | "PENDING" | "INACTIVE";
+}
+interface AppSummary {
+    id: string;
+    tenantId: string;
+    shortId: string;
+    subdomain: string;
+    brand: string;
+    domains: AppDomain[];
+    legacyId: number | null;
+    name: string;
+    description: string | null;
+    color: AppColor;
+    icon: string | null;
+    template: string | null;
+    planId: string;
+    allowSignup: boolean;
+    externalAccessEnabled: boolean;
+    currentVersion: AppVersion | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface AppDefinition {
+    id: string;
+    shortId: string;
+    subdomain: string;
+    brand: string;
+    domains: AppDomain[];
+    legacyId: number | null;
+    name: string;
+    description: string | null;
+    color: AppColor;
+    icon: string | null;
+    dataSourceId: string | null;
+    planId: string;
+    template: string | null;
+    allowSignup: boolean;
+    externalAccessEnabled: boolean;
+    currentVersion: AppVersion | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface AppFiles {
+    files: Record<string, string>;
+    [key: string]: unknown;
+}
+interface AppDeploy {
+    id: string;
+    appId: string;
+    appVersionId: string;
+    status: "PENDING" | "BUILDING" | "DEPLOYED" | "FAILED" | "CANCELLED";
+    deployUrl: string | null;
+    errorMessage: string | null;
+    logs: string | null;
+    durationMs: number | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+    createdAt: string;
+}
+interface AppVersion {
+    id: string;
+    appId: string;
+    status: AppVersionStatus;
+    currentDeploy: AppDeploy | null;
+    createdAt: string;
+}
+interface PublicFunctionResult {
+    success: boolean;
+    output: Record<string, unknown> | null;
+    error: string | null;
+}
+interface PublicFunctionAsyncResult {
+    id: string;
+    status: string;
+}
+/**
+ * Function list item. The three cron fields are populated only with `SCHEDULE_READ`; all three are
+ * also null when no schedule exists.
+ */
+interface FunctionSummary {
+    id: string;
+    tenantId: string;
+    appId: string | null;
+    legacyId: number | null;
+    name: string;
+    description: string | null;
+    runtime: string;
+    dataSourceId: string | null;
+    visibility: string;
+    cronExpression: string | null;
+    cronInputJson: Record<string, JsonValue> | null;
+    cronEnabled: boolean | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface FunctionListOptions extends PageOptions {
+    /** Optional case-insensitive name search. Blank values are ignored by the service. */
+    search?: string;
+}
+type FunctionVersionListOptions = PageOptions;
+type FunctionVisibility = "PRIVATE" | "PUBLIC";
+interface FunctionSecrets {
+    secrets: string[];
+}
+interface ColumnInput {
+    /** Column name in snake_case. */
+    name: string;
+    /** STRING, TEXT, INTEGER, DECIMAL, BOOLEAN, TIMESTAMP, UUID, or AUTO_INCREMENT. */
+    type: string;
+    /** Whether this column is the primary key. Defaults to false. */
+    primaryKey?: boolean;
+    /** Whether null values are accepted. Defaults to false. */
+    nullable?: boolean;
+    /** Optional database default expression or value. */
+    defaultValue?: string;
+}
+interface CustomQueryInput {
+    /** Unique lowercase name; underscores are accepted. */
+    name: string;
+    /** SELECT statement saved by the Data Manager. */
+    sql: string;
+    /** Whether the query is exposed as a Virtual Table. Defaults to false. */
+    isVirtualTable?: boolean;
+    /** Optional external connection for a Virtual Table. Omit for the app managed database. */
+    connectionId?: string;
+}
+interface CustomQueryUpdateInput {
+    name: string;
+    sql: string;
+    /** Defaults to false when omitted by the Data Manager producer. */
+    isVirtualTable?: boolean;
+    connectionId?: string;
+}
+interface CustomQuerySummary {
+    id: string;
+    name: string;
+    isVirtualTable: boolean;
+    connectionId: string | null;
+    createdAt: string | null;
+    updatedAt: string;
+}
+interface CustomQueryDefinition extends CustomQuerySummary {
+    sql: string;
+}
+type ImportSource = {
+    type: "SQL";
+    /** SELECT query executed against the current app's managed Data Source. */
+    query: string;
+} | {
+    type: "CSV";
+    /** File key returned by the upload endpoint. */
+    fileKey: string;
+    /** CSV separator. Defaults to comma. */
+    separator?: string;
+};
+interface ImportTarget {
+    /** Target table name in the current app's managed Data Source, at most 255 characters. */
+    tableName: string;
+    /** REPLACE truncates first, APPEND inserts, and UPSERT inserts or updates. */
+    mode: "REPLACE" | "APPEND" | "UPSERT";
+    /** Columns used to match existing rows in UPSERT mode. */
+    upsertKeyColumns?: string[];
+}
+interface ImportProcessing {
+    /** CHUNKED is parallel and default; STREAMING uses one worker. */
+    mode?: "CHUNKED" | "STREAMING";
+    /** Column used to order and split CHUNKED work. */
+    orderColumn?: string;
+    /** Rows per chunk. Defaults to 10000. */
+    chunkSize?: number;
+}
+interface ImportInput {
+    /** Optional identifier used when importing a definition from the legacy platform. */
+    legacyId?: number;
+    /** Display name of the reusable import definition. */
+    name: string;
+    /** SQL or uploaded CSV source read by the import. */
+    source: ImportSource;
+    /** Destination table and write behavior. */
+    target: ImportTarget;
+    /** Chunking strategy. Defaults to CHUNKED with chunks of 10000 rows. */
+    processing?: ImportProcessing;
+    /** Optional recurring schedule. Omission disables scheduling. */
+    schedule?: ImportSchedule;
+    /** Optional source-to-target column mapping. */
+    columnMappings?: ImportColumnMapping[];
+}
+interface ImportSchedule {
+    /** Cron expression evaluated by the Data Manager scheduler. */
+    cron?: string;
+    /** Whether the schedule is active. Defaults to false. */
+    enabled?: boolean;
+}
+interface ImportColumnMapping {
+    /** Column name in the source rows. */
+    source: string;
+    /** Column name in the target table. */
+    target: string;
+    /** Optional conversion type applied while importing. */
+    type?: string | null;
+}
+interface ImportDefinition {
+    id: string;
+    /** Legacy identifier when the import was migrated from the previous platform. */
+    legacyId: number | null;
+    name: string;
+    source: ImportSourceResponse;
+    target: Required<Pick<ImportTarget, "tableName" | "mode">> & {
+        upsertKeyColumns: string[] | null;
+    };
+    processing: {
+        mode: "CHUNKED" | "STREAMING";
+        orderColumn: string | null;
+        chunkSize: number;
+    };
+    schedule: {
+        cron: string | null;
+        enabled: boolean;
+    };
+    columnMappings: ImportColumnMapping[] | null;
+    createdAt: string;
+    updatedAt: string;
+}
+type ImportSourceResponse = {
+    type: "SQL";
+    query: string;
+} | {
+    type: "CSV";
+    fileKey: string;
+    separator: string;
+};
+interface ImportExecution {
+    id: string;
+    importDefinitionId: string;
+    /** Definition name captured for display, when available. */
+    importName: string | null;
+    status: "PENDING" | "PREPARING" | "RUNNING" | "COMPLETED" | "PARTIALLY_COMPLETED" | "FAILED" | "CANCELLED";
+    triggerType: "MANUAL" | "SCHEDULED" | "API";
+    totalChunks: number | null;
+    completedChunks: number;
+    failedChunks: number;
+    progressPercent: number | null;
+    rowsTotal: number | null;
+    rowsProcessed: number;
+    queuedAt: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    durationSeconds: number | null;
+    errorMessage: string | null;
+}
+interface AgentInput {
+    /** Agent name, 3 to 255 characters. */
+    name: string;
+    /** Optional description, at most 1000 characters. */
+    description?: string;
+    /** System instructions used for the agent. */
+    instructions?: string;
+    /** Complete list of Function UUIDs available to the agent. */
+    functionIds?: string[];
+    /** Shared provider connection used by the agent. */
+    connectionId?: string;
+    /**
+     * @deprecated The platform ignores the agent-level flag: autonomy is asked per chat
+     * through `AgentTaskCreateInput.autonomous`. Accepted and stored for compatibility.
+     */
+    autonomous?: boolean;
+}
+interface AgentDefinition extends AgentInput {
+    id: string;
+    functionIds: string[];
+    autonomous: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface AgentUpdateItem {
+    id: string;
+    /** Complete replacement. Omitted optionals are reset by the Functions service. */
+    update: AgentInput;
+}
+interface AgentBulkDeleteResult {
+    deleted: string[];
+    notFound: string[];
+    deletedCount: number;
+}
+interface WorkflowInput {
+    /** Workflow name, 3 to 255 characters. */
+    name: string;
+    /** Complete workflow definition including steps, conditions, context, and goto targets. */
+    definition: Record<string, unknown>;
+}
+interface WorkflowDefinition extends WorkflowInput {
+    id: string;
+    tenantId: string;
+    appId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface WorkflowSummary {
+    id: string;
+    tenantId: string;
+    appId: string | null;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface WorkflowExecution {
+    id: string;
+    tenantId: string;
+    appId: string | null;
+    workflowId: string;
+    triggerType: "MANUAL" | "SCHEDULED";
+    triggeredBy: string | null;
+    status: "PENDING" | "RUNNING" | "SUCCESS" | "FAILED" | "CANCELLED";
+    currentStepId: string | null;
+    context: Record<string, JsonValue> | null;
+    errorMessage: string | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+    createdAt: string;
+}
+interface IntegrationResourceParam {
+    type: string;
+    required: boolean;
+    defaultValue: JsonValue;
+    description: string | null;
+}
+interface IntegrationResourceInput {
+    /** Template config UUID that owns the resource. */
+    templateConfigId: string;
+    /** Resource name, unique per tenant and at most 100 characters. */
+    name: string;
+    /** HTTP method used by the resource. */
+    method: string;
+    /** Endpoint with optional `{{params.name}}` placeholders. */
+    endpoint: string;
+    /** Optional request body containing placeholders. */
+    body?: Record<string, JsonValue>;
+    /** Optional parameter schema. */
+    params?: Record<string, IntegrationResourceParam>;
+}
+type IntegrationResourceUpdateInput = Omit<IntegrationResourceInput, "templateConfigId">;
+interface IntegrationResource {
+    id: string;
+    tenantId: string;
+    templateConfigId: string;
+    name: string;
+    method: string;
+    endpoint: string;
+    body: Record<string, JsonValue> | null;
+    params: Record<string, IntegrationResourceParam>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface IntegrationResourceSummary {
+    id: string;
+    name: string;
+    method: string;
+    endpoint: string;
+}
+type IntegrationProxyMode = "OPEN" | "RESOURCE_ONLY";
+type IntegrationTemplateType = "GENERIC_AUTH" | "PROVIDER";
+type IntegrationConnectionStatus = "unchecked" | "connected" | "error";
+interface IntegrationTemplateSummary {
+    id: string;
+    name: string;
+    baseUrl: string | null;
+    proxyMode: IntegrationProxyMode;
+    logoUrl: string | null;
+    templateType: IntegrationTemplateType;
+}
+interface IntegrationTokenExtraction {
+    source: string | null;
+    path: string | null;
+    name: string | null;
+}
+interface IntegrationLoginConfig {
+    url: string | null;
+    method: string | null;
+    headers: Record<string, JsonValue> | null;
+    query_params: Record<string, JsonValue> | null;
+    body_form: Record<string, JsonValue> | null;
+    body: Record<string, JsonValue> | null;
+    token_extraction: IntegrationTokenExtraction | null;
+    token_ttl_seconds: number | null;
+}
+interface IntegrationCredentialRule {
+    placement: "HEADER" | "QUERY" | "COOKIE" | "BODY" | "BASIC" | null;
+    name: string | null;
+    path: string | null;
+    value: string | null;
+}
+interface IntegrationRequestConfig {
+    headers: Record<string, JsonValue> | null;
+    credential_rules: IntegrationCredentialRule[] | null;
+}
+interface IntegrationFieldSchema {
+    key: string;
+    label: string;
+    type: "url" | "text" | "secret";
+    required: boolean;
+    placeholder: string | null;
+    default: string | null;
+}
+interface IntegrationTemplate extends IntegrationTemplateSummary {
+    loginConfig: IntegrationLoginConfig | null;
+    requestConfig: IntegrationRequestConfig;
+    fieldsSchema: IntegrationFieldSchema[];
+    documentationUrl: string | null;
+}
+interface IntegrationExecution {
+    id: string;
+    templateConfigId: string;
+    appId: string | null;
+    method: string;
+    endpoint: string;
+    requestBody: JsonValue;
+    responseStatus: number | null;
+    responseBody: JsonValue;
+    durationMs: number | null;
+    success: boolean;
+    errorMessage: string | null;
+    source: string | null;
+    createdAt: string;
+}
+type CopilotProvider = "ANTHROPIC" | "OPENAI" | (string & {});
+interface AgentTaskCreateInput {
+    /** Optional title, at most 255 characters. */
+    title?: string;
+    /** Model harness accepted by Copilot, for example CLAUDE or CODEX. */
+    agentType: string;
+    /** Optional business agent UUID. */
+    agentId?: string;
+    /** Optional reasoning setting supported by the selected model. */
+    reasoningEffort?: string;
+    /** Owner for an on-behalf chat. Requires AGENT_WRITE in the current app. */
+    userId?: string;
+    /**
+     * Opens an ownerless chat that belongs to the named agent. Requires AGENT_WRITE and an
+     * agent holding a connection; mutually exclusive with `userId`.
+     */
+    autonomous?: boolean;
+}
+interface AgentTask {
+    id: string;
+    appId: string | null;
+    agentId: string | null;
+    userId: string | null;
+    title: string | null;
+    agentType: string;
+    reasoningEffort: string | null;
+    archived: boolean;
+    createdAt: string | null;
+    updatedAt: string;
+}
+interface AgentTaskListOptions extends PageOptions {
+    /** Include archived chats. Defaults to false. */
+    archived?: boolean;
+    /** Restrict to chats for one business agent. */
+    agentId?: string;
+    /** Search chat titles. */
+    search?: string;
+    /** Read another user's chats. Requires AGENT_WRITE in the current app. */
+    userId?: string;
+}
+type AgentTaskInput = {
+    type: "message";
+    content: string;
+    agentType?: string;
+    reasoningEffort?: string;
+} | {
+    type: "interrupt";
+} | {
+    type: "approval_response";
+    approved: boolean;
+};
+interface AgentTaskEvent {
+    /** Event names are open and can grow without a client release. */
+    type: string;
+    payload: unknown;
+    timestamp: number;
+    /** Present only on persisted structural events; live deltas omit it. */
+    sequence?: number;
+}
+interface AgentMessage {
+    id: string;
+    sender: string;
+    type: string;
+    content: string;
+    createdAt: string;
+}
+interface AgentModel {
+    model: string;
+    name: string;
+    provider: CopilotProvider;
+    agentType: string;
+    reasoningOptions: string[];
+}
+interface CredentialStatus {
+    provider: CopilotProvider;
+    connected: boolean;
+    credentialType: string | null;
+    accountEmail: string | null;
+    maskedApiKey: string | null;
+}
+interface OAuthStartResult {
+    authUrl: string;
+    state: string;
+}
+interface OAuthExchangeInput {
+    /** Authorization code returned by the provider. */
+    code: string;
+    /** Opaque state returned unchanged by `startOAuth`. */
+    state: string;
+}
+interface AuthenticationResult {
+    connected: boolean;
+    email: string | null;
+}
+interface DeviceAuthorization {
+    deviceAuthId: string;
+    userCode: string;
+    verificationUri: string;
+    intervalSeconds: number;
+}
+interface AgentConnectionCreateInput {
+    /** Connection name, at most 255 characters. */
+    name: string;
+    /** Provider to connect during creation. Must be paired with `apiKey`. */
+    provider?: CopilotProvider;
+    /** Write-only key. Must be paired with `provider`. */
+    apiKey?: string;
+}
+interface ProviderCredentialStatus {
+    provider: CopilotProvider;
+    connected: boolean;
+    credentialType: string | null;
+    accountEmail: string | null;
+}
+interface AgentConnection {
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+    credentials: ProviderCredentialStatus[];
+}
+interface MessageAccepted {
+    /** Identifier assigned by Messenger to the accepted notification. */
+    messageId: string;
+}
+interface AppContext {
+    appId: string;
+    app: AppDefinition;
+    tables: SchemaTables[];
+    functions: FunctionSummary[];
+    functionsTotal: number;
+    functionsTruncated: boolean;
+    agents: AgentDefinition[];
+    agentsTotal: number;
+    agentsTruncated: boolean;
+    files: string[];
+    integrations: TemplateConfigSummary[];
+    integrationsTotal: number;
+    integrationsTruncated: boolean;
+    connections: AgentConnection[];
+}
+
+interface AgentConnectionsModule {
+    /** Lists app connections with safe per-provider status and no credentials. */
+    list(): Promise<AgentConnection[]>;
+    get(id: string): Promise<AgentConnection>;
+    /** Creates an unauthenticated provider container. */
+    create(name: string): Promise<AgentConnection>;
+    /**
+     * Creates 1 to 100 connections atomically. A provider and API key must be supplied together;
+     * when present, the item is created and authenticated as one operation.
+     */
+    bulkCreate(inputs: AgentConnectionCreateInput[]): Promise<AgentConnection[]>;
+    delete(id: string): Promise<void>;
+    /** Validates and saves a write-only API key for one provider. */
+    saveApiKey(id: string, provider: CopilotProvider, apiKey: string): Promise<void>;
+    /** Disconnects one provider without deleting the connection container. */
+    disconnectProvider(id: string, provider: CopilotProvider): Promise<void>;
+    startOAuth(id: string, provider: CopilotProvider): Promise<OAuthStartResult>;
+    exchangeOAuth(id: string, provider: CopilotProvider, input: OAuthExchangeInput): Promise<AuthenticationResult>;
+    startDeviceAuthorization(id: string, provider: CopilotProvider): Promise<DeviceAuthorization>;
+    pollDeviceAuthorization(id: string, provider: CopilotProvider, deviceAuthId: string): Promise<AuthenticationResult>;
+}
+declare function createAgentConnectionsModule(transport: Transport, errors?: SdkCoreErrorFactory): AgentConnectionsModule;
+
+interface AgentCredentialsModule {
+    /** Lists safe credential status. Raw credentials never leave Copilot. */
+    list(): Promise<CredentialStatus[]>;
+    /** Lists models backed by a usable credential, optionally through a business agent connection. */
+    listModels(agentId?: string): Promise<AgentModel[]>;
+    /** Validates and stores a write-only API key. */
+    saveApiKey(provider: CopilotProvider, apiKey: string): Promise<void>;
+    /** Permanently removes the current credential for a provider. */
+    remove(provider: CopilotProvider): Promise<void>;
+    /** Starts provider OAuth and returns an opaque state that must be preserved. */
+    startOAuth(provider: CopilotProvider): Promise<OAuthStartResult>;
+    /** Exchanges provider OAuth code and state, saving the resulting credential. */
+    exchangeOAuth(provider: CopilotProvider, input: OAuthExchangeInput): Promise<AuthenticationResult>;
+    /** Starts a provider device flow and returns its polling interval. */
+    startDeviceAuthorization(provider: CopilotProvider): Promise<DeviceAuthorization>;
+    /** Polls one device authorization. Respect the returned start interval between calls. */
+    pollDeviceAuthorization(provider: CopilotProvider, deviceAuthId: string): Promise<AuthenticationResult>;
+}
+declare function createAgentCredentialsModule(transport: Transport, errors?: SdkCoreErrorFactory): AgentCredentialsModule;
+
+interface AgentsModule {
+    /** Lists the current app's business agents. Defaults: page 0, size 20, sort name. */
+    list(options?: PageOptions): Promise<Page<AgentDefinition>>;
+    get(id: string): Promise<AgentDefinition>;
+    create(input: AgentInput): Promise<AgentDefinition>;
+    /**
+     * Fully replaces an agent. Omitted `functionIds` becomes empty and omitted `autonomous` becomes false.
+     * The complete `functionIds` list replaces the previous association list.
+     */
+    update(id: string, input: AgentInput): Promise<AgentDefinition>;
+    delete(id: string): Promise<void>;
+    /** Creates 1 to 100 agents atomically. */
+    bulkCreate(inputs: AgentInput[]): Promise<AgentDefinition[]>;
+    /** Updates 1 to 100 agents atomically using complete replacement payloads. */
+    bulkUpdate(items: AgentUpdateItem[]): Promise<AgentDefinition[]>;
+    /** Deletes 1 to 100 unique ids and reports missing ids without failing the batch. */
+    bulkDelete(ids: string[]): Promise<AgentBulkDeleteResult>;
+    /** Lists models the named agent's connection can actually execute. */
+    listModels(agentId: string): Promise<AgentModel[]>;
+}
+declare function createAgentsModule(functionsTransport: Transport, copilotTransport: Transport, errors?: SdkCoreErrorFactory): AgentsModule;
+
+interface AgentTasksModule {
+    /** Lists chats newest first. `userId` on-behalf reads require AGENT_WRITE in the current app. */
+    list(options?: AgentTaskListOptions): Promise<Page<AgentTask>>;
+    get(id: string): Promise<AgentTask>;
+    /** Opens a chat. `autonomous: true` produces an ownerless chat that belongs to the agent. */
+    create(input: AgentTaskCreateInput): Promise<AgentTask>;
+    /** Renames a chat. Title is required and at most 255 characters. */
+    rename(id: string, title: string): Promise<AgentTask>;
+    /** Archives a chat and cleans up its live relay. */
+    archive(id: string): Promise<void>;
+    /**
+     * Sends a message, interrupt, or approval response through Copilot's HTTP channel.
+     * Replay is intentionally excluded: HTTP recovery reads persisted messages instead.
+     */
+    sendInput(id: string, input: AgentTaskInput): Promise<void>;
+    /** Lists persisted messages. Defaults: page 0, size 50, sort createdAt. */
+    listMessages(id: string, options?: PageOptions): Promise<Page<AgentMessage>>;
+}
+declare function createAgentTasksModule(transport: Transport, errors?: SdkCoreErrorFactory): AgentTasksModule;
+
+interface AppsModule {
+    /** Lists tenant apps. App-scoped tokens cannot call this collection operation. */
+    list(options?: AppListOptions): Promise<Page<AppSummary>>;
+    /** Gets one app, optionally selecting its DRAFT or PUBLISHED version. */
+    get(appId: string, options?: AppGetOptions): Promise<AppDefinition>;
+    /** Creates an app with an initial DRAFT version. App-scoped tokens cannot call this method. */
+    create(input: AppCreateInput): Promise<AppDefinition>;
+    /** Permanently deletes an app, every version, and every deployed artifact. */
+    delete(appId: string): Promise<void>;
+    /** Patches app metadata. Omitted fields are preserved. */
+    update(appId: string, input: AppUpdateInput): Promise<AppDefinition>;
+    /** Gets the complete file map for the current app version. */
+    getFiles(appId: string): Promise<AppFiles>;
+    /** Replaces the complete DRAFT file map. Files omitted from the input are deleted. */
+    replaceFiles(appId: string, files: Record<string, string>): Promise<AppFiles>;
+    /** Merges DRAFT files. Null deletes one path; omitted paths are preserved. */
+    mergeFiles(appId: string, files: Record<string, string | null>): Promise<AppFiles>;
+    /** Starts an asynchronous preview build from a snapshot of the current DRAFT. */
+    build(appId: string): Promise<AppDeploy>;
+    /** Starts an asynchronous build and publishes only after its successful callback. */
+    publish(appId: string, options?: AppPublishOptions): Promise<AppDefinition>;
+    /** Gets a deploy by id. Prefer this stable id for polling. */
+    getDeploy(appId: string, deployId: string): Promise<AppDeploy>;
+    /** Gets the deploy currently referenced by the app version, or null. */
+    getCurrentDeploy(appId: string): Promise<AppDeploy | null>;
+    /** Logically cancels a BUILDING deploy. Late callbacks cannot publish it. */
+    cancelBuild(appId: string, deployId: string): Promise<AppDeploy>;
+    /** Instantly points the app at a previous DEPLOYED version without rebuilding. */
+    rollback(appId: string, targetVersionId: string): Promise<AppDefinition>;
+    /** Lists deploy history. Defaults to page 0, size 20, and `createdAt,desc`; maximum size is 100. */
+    listDeploys(appId: string, options?: PageOptions): Promise<Page<AppDeploy>>;
+    /** Lists immutable versions. Defaults to page 0, size 20, and `createdAt,desc`; maximum size is 100. */
+    listVersions(appId: string, options?: PageOptions): Promise<Page<AppVersion>>;
+}
+declare function createAppsModule(transport: Transport, errors?: SdkCoreErrorFactory): AppsModule;
 
 interface AuthModule {
     me(): Promise<User>;
+    /** Lists user plans available for identity provisioning. */
+    listUserPlans(): Promise<UserPlan[]>;
 }
 declare function createAuthModule(transport: Transport, errors?: SdkCoreErrorFactory): AuthModule;
 
+interface FunctionsAdminModule {
+    /**
+     * Lists app Functions. Defaults: page 0, size 20, sort name.
+     *
+     * With `SCHEDULE_READ`, each item includes its composed cron fields. Without that permission,
+     * all three fields are null, which is also the shape of a Function without a schedule.
+     */
+    list(options?: FunctionListOptions): Promise<Page<FunctionSummary>>;
+    /**
+     * Gets one Function. Its composed cron fields follow the same permission-dependent semantics as
+     * `list`: all null can mean either no schedule or no `SCHEDULE_READ` permission.
+     */
+    get(id: string): Promise<FunctionDefinition>;
+    /**
+     * Creates a Function and optionally configures its schedule through the same request.
+     *
+     * Supplying any of `cronExpression`, `cronInputJson`, or `cronEnabled` requires a non-blank
+     * expression. The new schedule uses UTC and starts enabled unless `cronEnabled` is false.
+     * Scheduling also requires `SCHEDULE_WRITE` and `FUNCTION_EXECUTE`.
+     */
+    create(input: FunctionCreateInput): Promise<FunctionDefinition>;
+    /**
+     * Partially updates mutable fields.
+     *
+     * Omitted and null fields preserve their stored values. Empty values are applied when accepted
+     * by the field. The three cron fields form one composed scheduling unit: a blank expression
+     * removes the schedule, a non-blank expression can create a missing schedule in UTC, an empty
+     * input object clears it, and `cronEnabled` explicitly pauses or resumes it. Schedule changes
+     * require `SCHEDULE_WRITE` and `FUNCTION_EXECUTE`.
+     */
+    patch(id: string, input: FunctionPatchInput): Promise<FunctionDefinition>;
+    delete(id: string): Promise<void>;
+    /**
+     * Creates 1 to 100 Functions in a single transaction. Any failure creates none of them.
+     *
+     * SQL Functions require `dataSourceId`; every other runtime rejects it. Requires a token with an
+     * `app_id` claim. Embedded cron fields are prohibited in every bulk operation; compose a schedule
+     * through single-Function `create` instead.
+     */
+    bulkCreate(functions: FunctionBulkCreateInput[]): Promise<FunctionDefinition[]>;
+    /**
+     * Updates 1 to 100 Functions.
+     *
+     * WARNING: each `update` is a FULL REPLACEMENT, not a patch. An optional field you omit is
+     * CLEARED, not preserved: leave out `description`, `inputSchema`, `outputSchema`, or `secrets`
+     * and the stored value becomes empty. `name` and `code` are required on every item. This is the
+     * opposite of the legacy `updateServerFunctionMitra`, which preserved whatever it did not
+     * receive. Always send the complete desired state.
+     *
+     * Embedded cron fields are prohibited in every bulk operation. Requires a token with an `app_id`
+     * claim.
+     */
+    bulkUpdate(functions: FunctionBulkUpdateItem[]): Promise<FunctionDefinition[]>;
+    /**
+     * Partially updates 1 to 100 Functions while preserving omitted and null fields. Embedded cron
+     * fields are prohibited in every bulk operation; compose schedule changes through
+     * single-Function `patch` instead.
+     */
+    bulkPatch(functions: FunctionBulkPatchItem[]): Promise<FunctionDefinition[]>;
+    /**
+     * Deletes Functions by id, or every Function in the app with `{ allInApp: true }`.
+     *
+     * The two selectors are mutually exclusive: pass exactly one. `allInApp` deletes nothing and
+     * fails when the app holds more than 100 Functions.
+     */
+    bulkDelete(selector: FunctionBulkDeleteInput): Promise<FunctionBulkDeleteResult>;
+    /** Publishes the current DRAFT version. */
+    publish(id: string): Promise<FunctionDefinition>;
+    /** Creates a new current version from an earlier version UUID. */
+    rollback(id: string, versionId: string): Promise<FunctionDefinition>;
+    listVersions(id: string, options?: FunctionVersionListOptions): Promise<Page<FunctionVersion>>;
+    /** Changes PRIVATE/PUBLIC visibility without replacing the Function. */
+    setVisibility(id: string, visibility: FunctionVisibility): Promise<FunctionDefinition>;
+    listExecutions(id: string, options?: PageOptions): Promise<Page<FunctionExecution>>;
+    getExecution(functionId: string, executionId: string): Promise<FunctionExecution>;
+    /** Lists secret names only. Secret values never leave Functions. */
+    listSecrets(id: string): Promise<FunctionSecrets>;
+    /** Creates or replaces a write-only secret value. */
+    createSecret(id: string, name: string, value: string): Promise<void>;
+    /** Permanently deletes a secret by name. */
+    deleteSecret(id: string, name: string): Promise<void>;
+}
+declare function createFunctionsAdminModule(transport: Transport, errors?: SdkCoreErrorFactory): FunctionsAdminModule;
+
+interface IntegrationAdminModule {
+    /** Creates one integration config. Secret values are write-only. */
+    create(input: TemplateConfigCreateInput): Promise<TemplateConfig>;
+    /** Updates one config. Omitting `values` preserves stored credentials. */
+    update(id: string, input: Omit<TemplateConfigUpdateInput, "configId">): Promise<TemplateConfig>;
+    /** Permanently deletes one config and its stored credentials. */
+    delete(id: string): Promise<void>;
+    /**
+     * Creates 1 to 100 integration template configs.
+     *
+     * The whole batch is validated first, then items run in order, NOT atomically: read `results`
+     * for the outcome of each one. `values` hold credentials and never come back in any response.
+     */
+    bulkCreate(configs: TemplateConfigCreateInput[]): Promise<TemplateConfigBulkResult>;
+    /**
+     * Updates 1 to 100 integration template configs, in order and NOT atomically.
+     *
+     * Note the exception to the platform's bulk update rule: omitting `values` PRESERVES the stored
+     * configuration instead of clearing it, unlike `functionsAdmin.bulkUpdate`, where an omitted
+     * field is wiped. Sending `values` replaces the whole map.
+     */
+    bulkUpdate(configs: TemplateConfigUpdateInput[]): Promise<TemplateConfigBulkResult>;
+    /** Deletes 1 to 100 template configs by id, in order and NOT atomically. */
+    bulkDelete(configIds: string[]): Promise<TemplateConfigBulkResult>;
+    /** Tests provisional credentials against a template without storing anything. */
+    testCredentials(request: TestCredentialsInput): Promise<ConnectionTestResult>;
+    /** Tests a stored template config using the credentials it already holds. */
+    testConfig(configId: string): Promise<ConnectionTestResult>;
+    /** Lists the app's template configs, one page at a time. Credentials are never included. */
+    list(options?: ListTemplateConfigsOptions): Promise<TemplateConfigPage>;
+    /** Lists proxy executions for one config. Defaults: page 0, size 20, newest first. */
+    listExecutions(configId: string, options?: ListTemplateConfigsOptions): Promise<LegacyPage<IntegrationExecution>>;
+    getExecution(configId: string, executionId: string): Promise<IntegrationExecution>;
+}
+declare function createIntegrationAdminModule(transport: Transport, errors?: SdkCoreErrorFactory): IntegrationAdminModule;
+
+interface SchemaModule {
+    /** Creates a table in the current app schema. */
+    createTable(tableName: string, columns: ColumnInput[]): Promise<void>;
+    /** Lists APP and/or SHARED tables. Column details are omitted unless requested. */
+    listTables(options?: ListTablesOptions): Promise<SchemaTables[]>;
+    /** Lightweight alias for `listTables({ scope: "APP" })`. */
+    listAppTables(options?: Pick<ListTablesOptions, "includeColumns">): Promise<SchemaTables[]>;
+    /** Gets columns, primary keys, and foreign keys for one table. */
+    getTable(tableName: string): Promise<TableDefinition>;
+    /** Permanently drops a table and all of its rows. */
+    dropTable(tableName: string): Promise<void>;
+    /** Permanently deletes every row while keeping the table definition. */
+    truncateTable(tableName: string): Promise<void>;
+    /** Adds one column to an existing table. */
+    addColumn(tableName: string, column: ColumnInput): Promise<void>;
+    /** Permanently drops one column and its stored values. */
+    dropColumn(tableName: string, columnName: string): Promise<void>;
+}
+declare function createSchemaModule(transport: Transport, errors?: SdkCoreErrorFactory): SchemaModule;
+
+interface ContextModule {
+    /**
+     * Reads safe authoring context sequentially and fails on the first unavailable capability.
+     *
+     * Function code, file contents, integration secrets, and connection credentials are excluded.
+     * Summary lists are capped at 2000 and report total and truncation metadata.
+     */
+    getAppContext(): Promise<AppContext>;
+}
+interface ContextModuleDependencies {
+    apps: AppsModule;
+    schema: SchemaModule;
+    functionsAdmin: FunctionsAdminModule;
+    agents: AgentsModule;
+    integrationAdmin: IntegrationAdminModule;
+    agentConnections: AgentConnectionsModule;
+    getAppId?: (() => string | undefined) | undefined;
+}
+declare function createContextModule(dependencies: ContextModuleDependencies, errors?: SdkCoreErrorFactory): ContextModule;
+
+interface CustomQueriesModule {
+    /** Lists reusable SELECT queries without SQL. Defaults: page 0, size 20, sort name. */
+    list(options?: PageOptions): Promise<Page<CustomQuerySummary>>;
+    get(id: string): Promise<CustomQueryDefinition>;
+    /** Creates a named SELECT query. */
+    create(input: CustomQueryInput): Promise<CustomQueryDefinition>;
+    /** Fully replaces name, SQL, and Virtual Table settings. */
+    update(id: string, input: CustomQueryUpdateInput): Promise<CustomQueryDefinition>;
+    /** Permanently deletes a saved query. */
+    delete(id: string): Promise<void>;
+    /** Executes a saved query using driver-bound named parameters. */
+    execute(id: string, parameters?: Record<string, unknown>): Promise<QueryResult>;
+}
+declare function createCustomQueriesModule(transport: Transport, errors?: SdkCoreErrorFactory): CustomQueriesModule;
+
+interface DataSourcesModule {
+    /** Lists safe Data Source metadata. Stored credentials are never returned. */
+    list(options?: PageOptions): Promise<Page<DataSourceDefinition>>;
+    get(id: string): Promise<DataSourceDefinition>;
+    /** Creates one external Data Source. */
+    create(input: DataSourceCreateInput): Promise<DataSourceDefinition>;
+    /** Updates one external Data Source. Omitting credentials preserves stored values. */
+    update(id: string, input: Omit<DataSourceUpdateInput, "dataSourceId">): Promise<DataSourceDefinition>;
+    /** Permanently deletes one external Data Source. */
+    delete(id: string): Promise<void>;
+    /**
+     * Registers 1 to 100 `EXTERNAL` data sources. Mitra-managed instance types are rejected.
+     *
+     * The SDK composes the existing singular API in order, best effort and NOT atomically: metadata
+     * and the credential land per item, so a later failure leaves earlier items created. Read
+     * `results` to find out what happened to each one.
+     */
+    bulkCreate(dataSources: DataSourceCreateInput[]): Promise<DataSourceBulkResult>;
+    /**
+     * Updates 1 to 100 data sources, best effort and NOT atomically, like `bulkCreate`.
+     *
+     * Credentials are write-only. Omitting `credential` on a connection config PRESERVES the stored
+     * secret; sending one replaces it. Credentials never come back in responses, errors, or logs.
+     */
+    bulkUpdate(dataSources: DataSourceUpdateInput[]): Promise<DataSourceBulkResult>;
+    /** Deletes 1 to 100 data sources by id, best effort and NOT atomically. */
+    bulkDelete(dataSourceIds: string[]): Promise<DataSourceBulkResult>;
+}
+declare function createDataSourcesModule(transport: Transport, errors?: SdkCoreErrorFactory): DataSourcesModule;
+
 interface EntitiesModule {
     getTable<T = Record<string, unknown>>(tableName: string): EntityTable<T>;
 }
@@ -130,42 +1482,338 @@ interface FunctionsModule {
 }
 declare function createFunctionsModule(transport: Transport, options?: FunctionsModuleOptions, errors?: SdkCoreErrorFactory): FunctionsModule;
 
+interface ImportExecutionListOptions extends PageOptions {
+    /** Import definition UUID. */
+    definitionId: string;
+}
+interface ImportsModule {
+    /** Lists import definitions. Defaults: page 0, size 20, sort name. */
+    list(options?: PageOptions): Promise<Page<ImportDefinition>>;
+    get(id: string): Promise<ImportDefinition>;
+    create(input: ImportInput): Promise<ImportDefinition>;
+    /** Fully replaces an import definition. */
+    update(id: string, input: Omit<ImportInput, "legacyId">): Promise<ImportDefinition>;
+    /** Permanently deletes an import definition. */
+    delete(id: string): Promise<void>;
+    /** Queues an import and returns its execution. */
+    execute(id: string): Promise<ImportExecution>;
+    /** Lists executions for one definition, newest queued first. */
+    listExecutions(options: ImportExecutionListOptions): Promise<Page<ImportExecution>>;
+    /** Requests cancellation. A terminal execution cannot be changed. */
+    cancelExecution(executionId: string): Promise<ImportExecution>;
+}
+declare function createImportsModule(transport: Transport, errors?: SdkCoreErrorFactory): ImportsModule;
+
 interface IntegrationModule {
     executeResource(resourceId: string, params?: Record<string, unknown>): Promise<ProxyResult>;
     execute(configId: string, request: ProxyInput): Promise<ProxyResult>;
+    executeByAlias(alias: string, request: ProxyInput): Promise<ProxyResult>;
 }
 declare function createIntegrationModule(transport: Transport, errors?: SdkCoreErrorFactory): IntegrationModule;
 
+interface IntegrationResourcesModule {
+    /** Lists resources. Defaults: page 0, size 20, sort name ascending. */
+    list(options?: PageOptions): Promise<LegacyPage<IntegrationResourceSummary>>;
+    /** Gets one complete resource, including body, parameter schema, owner, and timestamps. */
+    get(id: string): Promise<IntegrationResource>;
+    create(input: IntegrationResourceInput): Promise<IntegrationResource>;
+    /** Fully replaces resource request settings. */
+    update(id: string, input: IntegrationResourceUpdateInput): Promise<IntegrationResource>;
+    delete(id: string): Promise<void>;
+}
+declare function createIntegrationResourcesModule(transport: Transport, errors?: SdkCoreErrorFactory): IntegrationResourcesModule;
+
+interface IntegrationTemplatesModule {
+    /** Lists template summaries. Defaults: page 0, size 20, sort name. */
+    list(options?: PageOptions): Promise<LegacyPage<IntegrationTemplateSummary>>;
+    /** Gets the complete login, request, and credential field schema for one template. */
+    get(id: string): Promise<IntegrationTemplate>;
+    /** Lists saved config summaries. Credentials and secret values are never returned. */
+    listConfigs(options?: PageOptions): Promise<TemplateConfigPage>;
+    /** Gets one saved config with its stored safe config references and connection metadata. */
+    getConfig(id: string): Promise<TemplateConfig>;
+}
+declare function createIntegrationTemplatesModule(transport: Transport, errors?: SdkCoreErrorFactory): IntegrationTemplatesModule;
+
+interface MembersModule {
+    /**
+     * Lists the users with effective access to the token's app: owners, admins, and managers whose
+     * access is derived from their tenant role, plus users holding an explicit app grant.
+     *
+     * Read only. Requires the `MEMBER_READ` resource and a token with an `app_id` claim.
+     */
+    list(): Promise<AppMember[]>;
+    /** Invites one user to an app. Requires an app-scoped token bound to the same `appId`. */
+    invite(appId: string, input: InviteAppUserInput): Promise<void>;
+    /** Revokes one user's app access. This does not delete the user's tenant identity. */
+    unsubscribe(appId: string, userId: string): Promise<void>;
+    /** Invites 1 to 100 users atomically. */
+    bulkInvite(appId: string, users: InviteAppUserInput[]): Promise<void>;
+    /** Revokes 1 to 100 unique users and reports ids not currently subscribed. */
+    bulkUnsubscribe(appId: string, userIds: string[]): Promise<BulkUnsubscribeResult>;
+}
+declare function createMembersModule(transport: Transport, errors?: SdkCoreErrorFactory): MembersModule;
+
+interface MessengerModule {
+    /** Sends plain text to the authenticated user; channel rendering may support markdown. */
+    notify(content: string): Promise<MessageAccepted>;
+}
+declare function createMessengerModule(transport: Transport, errors?: SdkCoreErrorFactory): MessengerModule;
+
+interface PublicFunctionsModule {
+    /**
+     * Executes a PUBLIC Function anonymously and waits for the terminal outcome.
+     *
+     * The response deliberately excludes input, logs, version, and timing information.
+     */
+    execute(id: string, input?: Record<string, unknown>): Promise<PublicFunctionResult>;
+    /** Queues a PUBLIC Function anonymously as fire-and-forget and returns its initial status. */
+    executeAsync(id: string, input?: Record<string, unknown>): Promise<PublicFunctionAsyncResult>;
+}
+declare function createPublicFunctionsModule(transport: Transport | undefined, errors?: SdkCoreErrorFactory): PublicFunctionsModule;
+
 interface QueriesModule {
     execute(id: string, parameters?: Record<string, unknown>): Promise<QueryResult>;
 }
-declare function createQueriesModule(transport: Transport, getDataSourceId: () => string | undefined, errors?: SdkCoreErrorFactory): QueriesModule;
+declare function createQueriesModule(transport: Transport, errors?: SdkCoreErrorFactory): QueriesModule;
+
+interface SqlModule {
+    /**
+     * Executes one parameterized SELECT, INSERT, UPDATE, or DELETE statement.
+     * Values must use named parameters and must not be interpolated into SQL.
+     */
+    executeQuery(sql: string, parameters?: Record<string, unknown>): Promise<QueryResult>;
+    /**
+     * Runs 1 to 20 DDL statements in one transaction, in order, on the app's managed data source.
+     *
+     * The batch is atomic: any failure rolls the whole list back, and the error carries the
+     * `failedIndex` of the offending statement. Responses omit `affectedRows` on this path.
+     */
+    executeDdl(statements: DdlStatement[]): Promise<BatchExecution>;
+    /**
+     * Runs 1 to 20 DML statements in one transaction, in order, on the app's managed data source.
+     *
+     * Named parameters are preserved per statement. `RETURNING` is rejected in a batch. The batch is
+     * atomic: any failure rolls the whole list back, and the error carries the `failedIndex`.
+     */
+    executeDml(statements: DmlStatement[]): Promise<BatchExecution>;
+    /** Lists the app's tables grouped by schema. Column details arrive only with `includeColumns`. */
+    listTables(options?: ListTablesOptions): Promise<SchemaTables[]>;
+}
+declare function createSqlModule(transport: Transport, errors?: SdkCoreErrorFactory): SqlModule;
+
+interface WorkflowsModule {
+    /** Lists app workflows. Defaults: page 0, size 20, sort name. */
+    list(options?: PageOptions): Promise<Page<WorkflowSummary>>;
+    get(id: string): Promise<WorkflowDefinition>;
+    create(input: WorkflowInput): Promise<WorkflowDefinition>;
+    /** Fully replaces both the name and complete workflow definition. */
+    update(id: string, input: WorkflowInput): Promise<WorkflowDefinition>;
+    delete(id: string): Promise<void>;
+    /** Queues a workflow and returns the PENDING execution. */
+    execute(id: string, input?: Record<string, unknown>): Promise<WorkflowExecution>;
+    /** Lists complete execution state. Defaults: page 0, size 20, service-defined creation sort. */
+    listExecutions(workflowId: string, options?: PageOptions): Promise<Page<WorkflowExecution>>;
+    /** Gets one execution with trigger, current step, context, error, and timestamps. */
+    getExecution(workflowId: string, executionId: string): Promise<WorkflowExecution>;
+    /** Requests cancellation. The service returns no body. */
+    cancelExecution(workflowId: string, executionId: string): Promise<void>;
+}
+declare function createWorkflowsModule(transport: Transport, errors?: SdkCoreErrorFactory): WorkflowsModule;
 
 interface SdkCoreTransports {
     auth: Transport;
     dataManager: Transport;
     functions: Transport;
     integration: Transport;
+    /** Code Studio transport. App-scoped adapters must prevent callers from targeting another app. */
+    codeStudio?: Transport;
+    /** Copilot transport for tasks, credentials, models, and app connections. */
+    copilot?: Transport;
+    /** Messenger transport for current-user notifications. */
+    messenger?: Transport;
+    /**
+     * Anonymous Functions transport. It must not add Authorization or X-App-Id headers.
+     * No fallback to the authenticated Functions transport is performed.
+     */
+    publicFunctions?: Transport;
 }
 interface SdkCoreOptions {
     transports: SdkCoreTransports;
-    getDataSourceId: () => string | undefined;
+    /** Resolves the app fixed by the concrete client without inspecting tokens in core. */
+    getAppId?: () => string | undefined;
     functions?: FunctionsModuleOptions;
     errors?: SdkCoreErrorFactory;
 }
 interface SdkCore {
+    readonly agentConnections: AgentConnectionsModule;
+    readonly agentCredentials: AgentCredentialsModule;
+    readonly agents: AgentsModule;
+    readonly agentTasks: AgentTasksModule;
+    readonly apps: AppsModule;
     readonly auth: AuthModule;
+    readonly context: ContextModule;
+    readonly customQueries: CustomQueriesModule;
+    readonly dataSources: DataSourcesModule;
     readonly entities: EntitiesProxy;
     readonly functions: FunctionsModule;
+    readonly functionsAdmin: FunctionsAdminModule;
+    readonly imports: ImportsModule;
     readonly integration: IntegrationModule;
+    readonly integrationAdmin: IntegrationAdminModule;
+    readonly integrationResources: IntegrationResourcesModule;
+    readonly integrationTemplates: IntegrationTemplatesModule;
+    readonly members: MembersModule;
+    readonly messenger: MessengerModule;
+    readonly publicFunctions: PublicFunctionsModule;
     readonly queries: QueriesModule;
+    readonly sql: SqlModule;
+    readonly schema: SchemaModule;
+    readonly workflows: WorkflowsModule;
 }
 declare function createSdkCore(options: SdkCoreOptions): SdkCore;
 
+interface AgentTaskEventObserver {
+    onEvent(event: AgentTaskEvent): void;
+    onDisconnect(error?: unknown): void;
+}
+interface AgentTaskEventConnection {
+    close(): void;
+}
+/** Streaming boundary implemented by concrete SDKs. Core never opens HTTP or WebSocket itself. */
+interface AgentTaskEventSource {
+    open(taskId: string, observer: AgentTaskEventObserver, signal?: AbortSignal, transport?: AgentSessionTransport): Promise<AgentTaskEventConnection>;
+}
+type AgentSessionTransport = "auto" | "websocket" | "http";
+interface NewAgentTaskSessionOptions {
+    create: true;
+    agentType: string;
+    title?: string;
+    agentId?: string;
+    reasoningEffort?: string;
+    userId?: string;
+    /** Adapter preference. Server adapters support `http`; browser adapters may support all values. */
+    transport?: AgentSessionTransport;
+}
+interface ExistingAgentTaskSessionOptions {
+    taskId: string;
+    transport?: AgentSessionTransport;
+}
+type AgentTaskSessionOptions = NewAgentTaskSessionOptions | ExistingAgentTaskSessionOptions;
+interface AgentSendOptions {
+    agentType?: string;
+    reasoningEffort?: string;
+}
+interface AgentSendAndWaitOptions extends AgentSendOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+type AgentTaskSessionStatus = "opening" | "idle" | "streaming" | "cancelled" | "error" | "closed";
+interface AgentQueueItem extends AgentSendOptions {
+    id: string;
+    text: string;
+    createdAt: number;
+}
+interface AgentToolEvent {
+    tool: string;
+    toolId?: string;
+    phase: "call" | "result";
+    input?: unknown;
+    content?: unknown;
+    timestamp?: number;
+}
+type AgentTimelineItem = {
+    id: string;
+    kind: "user" | "agent";
+    text: string;
+    at: string;
+} | {
+    id: string;
+    kind: "tool";
+    tool: AgentToolEvent;
+    at: string;
+};
+interface AgentTurnResult {
+    task: AgentTask;
+    content: string;
+    reason: string;
+}
+declare class AgentTaskTurnError extends Error {
+    readonly code: string | undefined;
+    constructor(message: string, code?: string);
+}
+interface AgentTaskSessionEventMap {
+    statusChange: {
+        status: AgentTaskSessionStatus;
+    };
+    historyLoaded: {
+        history: readonly AgentTimelineItem[];
+    };
+    taskCreated: {
+        task: AgentTask;
+    };
+    turnStart: Record<string, never>;
+    delta: {
+        delta: string;
+        kind: "text" | "thinking";
+    };
+    tool: AgentToolEvent;
+    workspace: {
+        payload: unknown;
+        timestamp: number;
+    };
+    turnEnd: AgentTurnResult;
+    cancelled: Record<string, never>;
+    queueChange: {
+        queue: readonly AgentQueueItem[];
+    };
+    error: {
+        code?: string;
+        error: string;
+    };
+    raw: AgentTaskEvent;
+}
+interface AgentTaskSession {
+    readonly taskId: string | null;
+    readonly task: AgentTask | null;
+    readonly isNew: boolean;
+    readonly status: AgentTaskSessionStatus;
+    readonly history: readonly AgentTimelineItem[];
+    readonly content: string;
+    readonly queue: readonly AgentQueueItem[];
+    send(prompt: string, options?: AgentSendOptions): void;
+    sendAndWait(prompt: string, options?: AgentSendAndWaitOptions): Promise<AgentTurnResult>;
+    cancel(): Promise<void>;
+    respondApproval(approved: boolean): void;
+    loadHistory(options?: {
+        limit?: number;
+    }): Promise<readonly AgentTimelineItem[]>;
+    editQueueItem(id: string, text: string): void;
+    removeQueueItem(id: string): void;
+    clearQueue(): void;
+    on<K extends keyof AgentTaskSessionEventMap>(event: K, handler: (payload: AgentTaskSessionEventMap[K]) => void): () => void;
+    close(): void;
+}
+interface AgentTaskSessionManager {
+    session(options: AgentTaskSessionOptions): AgentTaskSession;
+}
+type AgentTasksWithSessions = AgentTasksModule & AgentTaskSessionManager;
+interface AgentTaskSessionManagerOptions {
+    tasks: AgentTasksModule;
+    eventSource: AgentTaskEventSource;
+}
+declare function toAgentTimelineItem(message: AgentMessage): AgentTimelineItem;
+declare function createAgentTaskSessionManager(options: AgentTaskSessionManagerOptions): AgentTaskSessionManager;
+declare function withAgentTaskSessions(tasks: AgentTasksModule, manager: AgentTaskSessionManager): AgentTasksWithSessions;
+
 declare function encodePathSegment(value: string | number, name: string, errors?: SdkCoreErrorFactory): string;
 
 declare function expectObject<T extends object>(value: unknown, context: string, errors?: SdkCoreErrorFactory): T;
-declare function expectObjectArray<T extends object>(value: unknown, context: string, errors?: SdkCoreErrorFactory): T[];
+declare function expectObjectArray<T extends object>(value: unknown, context: string, errors?: SdkCoreErrorFactory, validateItem?: (value: unknown, context: string, errors: SdkCoreErrorFactory) => T): T[];
+declare function expectNullableObject<T extends object>(value: unknown, context: string, errors?: SdkCoreErrorFactory): T | null;
+declare function expectStringArray(value: unknown, context: string, errors?: SdkCoreErrorFactory): string[];
+declare function expectPage<T extends object>(value: unknown, context: string, errors?: SdkCoreErrorFactory, validateItem?: (value: unknown, context: string, errors: SdkCoreErrorFactory) => T): Page<T>;
+declare function expectLegacyPage<T extends object>(value: unknown, context: string, errors?: SdkCoreErrorFactory, validateItem?: (value: unknown, context: string, errors: SdkCoreErrorFactory) => T): LegacyPage<T>;
 declare function expectEmpty(value: unknown, context: string, errors?: SdkCoreErrorFactory): void;
 
-export { type AuthModule, type EmptyFunctionInput, type EntitiesModule, type EntitiesProxy, type EntityListOptions, type EntityTable, type FunctionExecution, type FunctionsModule, type FunctionsModuleOptions, type HttpMethod, type IntegrationModule, type InvocationType, type Plan, type ProxyInput, type ProxyResult, type QueriesModule, type QueryParamValue, type QueryResult, type SdkCore, SdkCoreConfigurationError, type SdkCoreErrorFactory, type SdkCoreOptions, SdkCoreResponseError, type SdkCoreTransports, type Tenant, type Transport, type TransportRequestOptions, type User, createAuthModule, createEntitiesModule, createFunctionsModule, createIntegrationModule, createQueriesModule, createSdkCore, defaultSdkCoreErrorFactory, encodePathSegment, expectEmpty, expectObject, expectObjectArray };
+export { type AgentBulkDeleteResult, type AgentConnection, type AgentConnectionCreateInput, type AgentConnectionsModule, type AgentCredentialsModule, type AgentDefinition, type AgentInput, type AgentMessage, type AgentModel, type AgentQueueItem, type AgentSendAndWaitOptions, type AgentSendOptions, type AgentSessionTransport, type AgentTask, type AgentTaskCreateInput, type AgentTaskEvent, type AgentTaskEventConnection, type AgentTaskEventObserver, type AgentTaskEventSource, type AgentTaskInput, type AgentTaskListOptions, type AgentTaskSession, type AgentTaskSessionEventMap, type AgentTaskSessionManager, type AgentTaskSessionManagerOptions, type AgentTaskSessionOptions, type AgentTaskSessionStatus, AgentTaskTurnError, type AgentTasksModule, type AgentTasksWithSessions, type AgentTimelineItem, type AgentToolEvent, type AgentTurnResult, type AgentUpdateItem, type AgentsModule, type AppColor, type AppContext, type AppCreateInput, type AppDefinition, type AppDeploy, type AppDomain, type AppFiles, type AppGetOptions, type AppListOptions, type AppMember, type AppPublishOptions, type AppSummary, type AppUpdateInput, type AppVersion, type AppVersionStatus, type AppsModule, type AuthModule, type AuthenticationResult, type BatchExecution, type BatchStatementResult, type BulkUnsubscribeResult, type ColumnInput, type ConnectionConfig, type ConnectionConfigResponse, type ConnectionTestResult, type ContextModule, type ContextModuleDependencies, type CopilotProvider, type CredentialStatus, type CustomQueriesModule, type CustomQueryDefinition, type CustomQueryInput, type CustomQuerySummary, type CustomQueryUpdateInput, type DataSourceBulkItemResult, type DataSourceBulkResult, type DataSourceCreateInput, type DataSourceDbType, type DataSourceDefinition, type DataSourceInstanceType, type DataSourceUpdateInput, type DataSourcesModule, type DdlStatement, type DeviceAuthorization, type DmlStatement, type EmptyFunctionInput, type EntitiesModule, type EntitiesProxy, type EntityListOptions, type EntityListResponse, type EntityTable, type ExistingAgentTaskSessionOptions, type FunctionBulkCreateInput, type FunctionBulkDeleteInput, type FunctionBulkDeleteResult, type FunctionBulkPatchInput, type FunctionBulkPatchItem, type FunctionBulkUpdateItem, type FunctionCreateInput, type FunctionDefinition, type FunctionExecution, type FunctionListOptions, type FunctionPatchInput, type FunctionRuntime, type FunctionSecrets, type FunctionSummary, type FunctionUpdateInput, type FunctionVersion, type FunctionVersionListOptions, type FunctionVisibility, type FunctionsAdminModule, type FunctionsModule, type FunctionsModuleOptions, type HttpMethod, type ImportColumnMapping, type ImportDefinition, type ImportExecution, type ImportExecutionListOptions, type ImportInput, type ImportProcessing, type ImportSchedule, type ImportSource, type ImportSourceResponse, type ImportTarget, type ImportsModule, type IntegrationAdminModule, type IntegrationConnectionStatus, type IntegrationCredentialRule, type IntegrationExecution, type IntegrationFieldSchema, type IntegrationLoginConfig, type IntegrationModule, type IntegrationProxyMode, type IntegrationRequestConfig, type IntegrationResource, type IntegrationResourceInput, type IntegrationResourceParam, type IntegrationResourceSummary, type IntegrationResourceUpdateInput, type IntegrationResourcesModule, type IntegrationTemplate, type IntegrationTemplateSummary, type IntegrationTemplateType, type IntegrationTemplatesModule, type IntegrationTokenExtraction, type InviteAppUserInput, type InvocationType, type JsonValue, type LegacyPage, type ListTablesOptions, type ListTemplateConfigsOptions, type MembersModule, type MessageAccepted, type MessengerModule, type NewAgentTaskSessionOptions, type OAuthExchangeInput, type OAuthStartResult, type Page, type PageOptions, type PlanPrice, type ProviderCredentialStatus, type ProxyInput, type ProxyResult, type PublicFunctionAsyncResult, type PublicFunctionResult, type PublicFunctionsModule, type QueriesModule, type QueryParamPrimitive, type QueryParamValue, type QueryResult, type SchemaModule, type SchemaScope, type SchemaTables, type SdkCore, SdkCoreConfigurationError, type SdkCoreErrorFactory, type SdkCoreOptions, SdkCoreResponseError, type SdkCoreTransports, type SqlModule, type TableColumn, type TableDefinition, type TableForeignKey, type TemplateConfig, type TemplateConfigBulkItemResult, type TemplateConfigBulkResult, type TemplateConfigCreateInput, type TemplateConfigPage, type TemplateConfigSummary, type TemplateConfigUpdateInput, type Tenant, type TestCredentialsInput, type Transport, type TransportRequestOptions, type User, type UserPlan, type WorkflowDefinition, type WorkflowExecution, type WorkflowInput, type WorkflowSummary, type WorkflowsModule, 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, expectPage, expectStringArray, toAgentTimelineItem, withAgentTaskSessions };