@objectstack/spec 3.0.8 → 3.0.9

package/dist/api/index.js

@@ -461,8 +461,17 @@ var ServiceInfoSchema = zod.z.object({
   route: zod.z.string().optional().describe("e.g. /api/v1/analytics"),
   /** Implementation provider name */
   provider: zod.z.string().optional().describe('e.g. "objectql", "plugin-redis", "driver-memory"'),
+  /** Service version */
+  version: zod.z.string().optional().describe('Semantic version of the service implementation (e.g. "3.0.6")'),
   /** Human-readable reason if unavailable */
-  message: zod.z.string().optional().describe('e.g. "Install plugin-workflow to enable"')
+  message: zod.z.string().optional().describe('e.g. "Install plugin-workflow to enable"'),
+  /** Rate limit configuration for this service */
+  rateLimit: zod.z.object({
+    requestsPerMinute: zod.z.number().int().optional().describe("Maximum requests per minute"),
+    requestsPerHour: zod.z.number().int().optional().describe("Maximum requests per hour"),
+    burstLimit: zod.z.number().int().optional().describe("Maximum burst request count"),
+    retryAfterMs: zod.z.number().int().optional().describe("Suggested retry-after delay in milliseconds when rate-limited")
+  }).optional().describe("Rate limit and quota info for this service")
 });
 var ApiRoutesSchema = zod.z.object({
   /** Base URL for Object CRUD (Data Protocol) */
@@ -516,11 +525,46 @@ var DiscoverySchema = zod.z.object({
   services: zod.z.record(zod.z.string(), ServiceInfoSchema).describe(
     "Per-service availability map keyed by CoreServiceName"
   ),
+  /**
+   * Hierarchical capability descriptors.
+   * Declares platform features so clients can adapt UI without probing individual services.
+   * Each key is a capability domain (e.g., "comments", "automation", "search"),
+   * and its value describes what sub-features are available.
+   */
+  capabilities: zod.z.record(zod.z.string(), zod.z.object({
+    enabled: zod.z.boolean().describe("Whether this capability is available"),
+    features: zod.z.record(zod.z.string(), zod.z.boolean()).optional().describe("Sub-feature flags within this capability"),
+    description: zod.z.string().optional().describe("Human-readable capability description")
+  })).optional().describe("Hierarchical capability descriptors for frontend intelligent adaptation"),
+  /**
+   * Schema discovery URLs for cross-ecosystem interoperability.
+   */
+  schemaDiscovery: zod.z.object({
+    openapi: zod.z.string().optional().describe('URL to OpenAPI (Swagger) specification (e.g., "/api/v1/openapi.json")'),
+    graphql: zod.z.string().optional().describe('URL to GraphQL schema endpoint (e.g., "/graphql")'),
+    jsonSchema: zod.z.string().optional().describe("URL to JSON Schema definitions")
+  }).optional().describe("Schema discovery endpoints for API toolchain integration"),
   /**
    * Custom metadata key-value pairs for extensibility
    */
   metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Custom metadata key-value pairs for extensibility")
 });
+var WellKnownCapabilitiesSchema = zod.z.object({
+  /** Whether the backend supports Feed / Chatter API */
+  feed: zod.z.boolean().describe("Whether the backend supports Feed / Chatter API"),
+  /** Whether the backend supports comments (a subset of Feed) */
+  comments: zod.z.boolean().describe("Whether the backend supports comments (a subset of Feed)"),
+  /** Whether the backend supports Automation CRUD (flows, triggers) */
+  automation: zod.z.boolean().describe("Whether the backend supports Automation CRUD (flows, triggers)"),
+  /** Whether the backend supports cron scheduling */
+  cron: zod.z.boolean().describe("Whether the backend supports cron scheduling"),
+  /** Whether the backend supports full-text search */
+  search: zod.z.boolean().describe("Whether the backend supports full-text search"),
+  /** Whether the backend supports async export */
+  export: zod.z.boolean().describe("Whether the backend supports async export"),
+  /** Whether the backend supports chunked (multipart) uploads */
+  chunkedUpload: zod.z.boolean().describe("Whether the backend supports chunked (multipart) uploads")
+}).describe("Well-known capability flags for frontend intelligent adaptation");
 var PresenceStatus = zod.z.enum([
   "online",
   // User is actively connected
@@ -4273,12 +4317,22 @@ zod.z.object({
     register: zod.z.function().describe("Register a driver")
   }).passthrough().describe("Driver Registry")
 });
+zod.z.object({
+  /** Version before upgrade */
+  previousVersion: zod.z.string().describe("Version before upgrade"),
+  /** Version after upgrade */
+  newVersion: zod.z.string().describe("Version after upgrade"),
+  /** Whether this is a major version bump */
+  isMajorUpgrade: zod.z.boolean().describe("Whether this is a major version bump"),
+  /** Metadata snapshot before upgrade (for migration logic) */
+  previousMetadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Metadata snapshot before upgrade")
+}).describe("Version migration context for onUpgrade hook");
 var PluginLifecycleSchema = zod.z.object({
   onInstall: zod.z.function().optional().describe("Called when plugin is installed"),
   onEnable: zod.z.function().optional().describe("Called when plugin is enabled"),
   onDisable: zod.z.function().optional().describe("Called when plugin is disabled"),
   onUninstall: zod.z.function().optional().describe("Called when plugin is uninstalled"),
-  onUpgrade: zod.z.function().optional().describe("Called when plugin is upgraded")
+  onUpgrade: zod.z.function().optional().describe("Called when plugin is upgraded. Receives UpgradeContext with previousVersion, newVersion, and isMajorUpgrade")
 });
 var CORE_PLUGIN_TYPES = [
   "ui",
@@ -4636,8 +4690,67 @@ var ManifestSchema = zod.z.object({
    * Configures how the plugin is loaded, initialized, and managed at runtime.
    * Includes strategies for lazy loading, code splitting, caching, and hot reload.
    */
-  loading: PluginLoadingConfigSchema.optional().describe("Plugin loading and runtime behavior configuration")
-});
+  loading: PluginLoadingConfigSchema.optional().describe("Plugin loading and runtime behavior configuration"),
+  /**
+   * Platform Compatibility Requirements.
+   * Specifies the minimum ObjectStack platform version required to run this package.
+   * Used at install time to prevent incompatible packages from being installed.
+   *
+   * @example
+   * ```yaml
+   * engine:
+   *   objectstack: ">=3.0.0"
+   * ```
+   */
+  engine: zod.z.object({
+    /** ObjectStack platform version requirement (SemVer range) */
+    objectstack: zod.z.string().regex(/^[><=~^]*\d+\.\d+\.\d+/).describe('ObjectStack platform version requirement (SemVer range, e.g. ">=3.0.0")')
+  }).optional().describe("Platform compatibility requirements")
+});
+var DependencyStatusEnum = zod.z.enum([
+  "satisfied",
+  // Already installed and version compatible
+  "needs_install",
+  // Not installed, needs to be installed
+  "needs_upgrade",
+  // Installed but version incompatible, needs upgrade
+  "conflict"
+  // Conflicts with another package's dependency
+]).describe("Resolution status for a dependency");
+var ResolvedDependencySchema = zod.z.object({
+  /** Package identifier of the dependency */
+  packageId: zod.z.string().describe("Dependency package identifier"),
+  /** SemVer range required by the parent package */
+  requiredRange: zod.z.string().describe('SemVer range required (e.g. "^2.0.0")'),
+  /** Actual version resolved (if available) */
+  resolvedVersion: zod.z.string().optional().describe("Actual version resolved from registry"),
+  /** Currently installed version (if any) */
+  installedVersion: zod.z.string().optional().describe("Currently installed version"),
+  /** Resolution status */
+  status: DependencyStatusEnum.describe("Resolution status"),
+  /** Conflict details (when status is "conflict") */
+  conflictReason: zod.z.string().optional().describe("Explanation of the conflict")
+}).describe("Resolution result for a single dependency");
+var RequiredActionSchema = zod.z.object({
+  /** Type of action required */
+  type: zod.z.enum(["install", "upgrade", "confirm_conflict"]).describe("Type of action required"),
+  /** Target package identifier */
+  packageId: zod.z.string().describe("Target package identifier"),
+  /** Human-readable description of the action */
+  description: zod.z.string().describe("Human-readable action description")
+}).describe("Action required before installation can proceed");
+var DependencyResolutionResultSchema = zod.z.object({
+  /** All dependencies and their resolution results */
+  dependencies: zod.z.array(ResolvedDependencySchema).describe("Resolution result for each dependency"),
+  /** Whether installation can proceed without conflicts */
+  canProceed: zod.z.boolean().describe("Whether installation can proceed"),
+  /** Actions that require user confirmation or system execution */
+  requiredActions: zod.z.array(RequiredActionSchema).describe("Actions required before proceeding"),
+  /** Topologically sorted package IDs for installation order */
+  installOrder: zod.z.array(zod.z.string()).describe("Topologically sorted package IDs for installation"),
+  /** Detected circular dependency chains */
+  circularDependencies: zod.z.array(zod.z.array(zod.z.string())).optional().describe('Circular dependency chains detected (e.g. [["A", "B", "A"]])')
+}).describe("Complete dependency resolution result");
 
 // src/kernel/package-registry.zod.ts
 var PackageStatusEnum = zod.z.enum([
@@ -4653,29 +4766,29 @@ var PackageStatusEnum = zod.z.enum([
   // Removal in progress
   "error"
   // Installation or runtime error
-]);
+]).describe("Package installation status");
 var InstalledPackageSchema = zod.z.object({
   /** 
    * The full package manifest (source of truth for package definition).
    */
-  manifest: ManifestSchema,
+  manifest: ManifestSchema.describe("Full package manifest"),
   /**
    * Current lifecycle status.
    */
-  status: PackageStatusEnum.default("installed"),
+  status: PackageStatusEnum.default("installed").describe("Package state: installed, disabled, installing, upgrading, uninstalling, or error"),
   /**
    * Whether the package is currently enabled (active).
    * When disabled, the package's metadata is not loaded into the registry.
    */
-  enabled: zod.z.boolean().default(true),
+  enabled: zod.z.boolean().default(true).describe("Whether the package is currently enabled"),
   /**
    * ISO 8601 timestamp of when the package was installed.
    */
-  installedAt: zod.z.string().datetime().optional(),
+  installedAt: zod.z.string().datetime().optional().describe("Installation timestamp"),
   /**
    * ISO 8601 timestamp of last update.
    */
-  updatedAt: zod.z.string().datetime().optional(),
+  updatedAt: zod.z.string().datetime().optional().describe("Last update timestamp"),
   /**
    * The currently installed version string.
    * Mirrors manifest.version for quick access without parsing the full manifest.
@@ -4689,73 +4802,124 @@ var InstalledPackageSchema = zod.z.object({
   /**
    * ISO 8601 timestamp of when the package was last enabled/disabled.
    */
-  statusChangedAt: zod.z.string().datetime().optional(),
+  statusChangedAt: zod.z.string().datetime().optional().describe("Status change timestamp"),
   /**
    * Error message if status is 'error'.
    */
-  errorMessage: zod.z.string().optional(),
+  errorMessage: zod.z.string().optional().describe("Error message when status is error"),
   /**
    * Configuration values set by the user for this package.
    * Keys correspond to the package's `configuration.properties`.
    */
-  settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-});
+  settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("User-provided configuration settings"),
+  /**
+   * Upgrade history for this package.
+   * Records each version migration with status and optional log.
+   */
+  upgradeHistory: zod.z.array(zod.z.object({
+    /** Previous version before upgrade */
+    fromVersion: zod.z.string().describe("Version before upgrade"),
+    /** New version after upgrade */
+    toVersion: zod.z.string().describe("Version after upgrade"),
+    /** Timestamp of the upgrade */
+    upgradedAt: zod.z.string().datetime().describe("Upgrade timestamp"),
+    /** Outcome of the upgrade */
+    status: zod.z.enum(["success", "failed", "rolled_back"]).describe("Upgrade outcome"),
+    /** Migration log entries */
+    migrationLog: zod.z.array(zod.z.string()).optional().describe("Migration step logs")
+  })).optional().describe("Version upgrade history"),
+  /**
+   * Namespaces registered by this package.
+   * Tracks which namespace prefixes are occupied by this package.
+   */
+  registeredNamespaces: zod.z.array(zod.z.string()).optional().describe("Namespace prefixes registered by this package")
+}).describe("Installed package with runtime lifecycle state");
+zod.z.object({
+  /** Namespace prefix */
+  namespace: zod.z.string().describe("Namespace prefix"),
+  /** Package that owns this namespace */
+  packageId: zod.z.string().describe("Owning package ID"),
+  /** Registration timestamp */
+  registeredAt: zod.z.string().datetime().describe("Registration timestamp"),
+  /** Namespace status */
+  status: zod.z.enum(["active", "disabled", "reserved"]).describe("Namespace status")
+}).describe("Namespace ownership entry in the registry");
+zod.z.object({
+  /** Error type discriminator */
+  type: zod.z.literal("namespace_conflict").describe("Error type"),
+  /** Namespace that was requested */
+  requestedNamespace: zod.z.string().describe("Requested namespace"),
+  /** ID of the package that already owns the namespace */
+  conflictingPackageId: zod.z.string().describe("Conflicting package ID"),
+  /** Name of the conflicting package */
+  conflictingPackageName: zod.z.string().describe("Conflicting package display name"),
+  /** Suggested alternative namespace */
+  suggestion: zod.z.string().optional().describe("Suggested alternative namespace")
+}).describe("Namespace collision error during installation");
 var ListPackagesRequestSchema = zod.z.object({
   /** Filter by status */
-  status: PackageStatusEnum.optional(),
+  status: PackageStatusEnum.optional().describe("Filter by package status"),
   /** Filter by package type */
-  type: ManifestSchema.shape.type.optional(),
+  type: ManifestSchema.shape.type.optional().describe("Filter by package type"),
   /** Filter by enabled state */
-  enabled: zod.z.boolean().optional()
-});
+  enabled: zod.z.boolean().optional().describe("Filter by enabled state")
+}).describe("List packages request");
 var ListPackagesResponseSchema = zod.z.object({
-  packages: zod.z.array(InstalledPackageSchema),
-  total: zod.z.number()
-});
+  packages: zod.z.array(InstalledPackageSchema).describe("List of installed packages"),
+  total: zod.z.number().describe("Total package count")
+}).describe("List packages response");
 var GetPackageRequestSchema = zod.z.object({
   /** Package ID (reverse domain identifier from manifest) */
-  id: zod.z.string()
-});
+  id: zod.z.string().describe("Package identifier")
+}).describe("Get package request");
 var GetPackageResponseSchema = zod.z.object({
-  package: InstalledPackageSchema
-});
+  package: InstalledPackageSchema.describe("Package details")
+}).describe("Get package response");
 var InstallPackageRequestSchema = zod.z.object({
   /** The package manifest to install */
-  manifest: ManifestSchema,
+  manifest: ManifestSchema.describe("Package manifest to install"),
   /** Optional: user-provided settings at install time */
-  settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("User-provided settings at install time"),
   /** Whether to enable immediately after install (default: true) */
-  enableOnInstall: zod.z.boolean().default(true)
-});
+  enableOnInstall: zod.z.boolean().default(true).describe("Whether to enable immediately after install"),
+  /**
+   * Current platform version for compatibility checking.
+   * When provided, the system compares this against the package's
+   * `engine.objectstack` requirement to verify compatibility.
+   */
+  platformVersion: zod.z.string().optional().describe("Current platform version for compatibility verification")
+}).describe("Install package request");
 var InstallPackageResponseSchema = zod.z.object({
-  package: InstalledPackageSchema,
-  message: zod.z.string().optional()
-});
+  package: InstalledPackageSchema.describe("Installed package details"),
+  message: zod.z.string().optional().describe("Installation status message"),
+  /** Dependency resolution result (when dependencies were analyzed) */
+  dependencyResolution: DependencyResolutionResultSchema.optional().describe("Dependency resolution result from install analysis")
+}).describe("Install package response");
 var UninstallPackageRequestSchema = zod.z.object({
   /** Package ID to uninstall */
-  id: zod.z.string()
-});
+  id: zod.z.string().describe("Package ID to uninstall")
+}).describe("Uninstall package request");
 var UninstallPackageResponseSchema = zod.z.object({
-  id: zod.z.string(),
-  success: zod.z.boolean(),
-  message: zod.z.string().optional()
-});
+  id: zod.z.string().describe("Uninstalled package ID"),
+  success: zod.z.boolean().describe("Whether uninstall succeeded"),
+  message: zod.z.string().optional().describe("Uninstall status message")
+}).describe("Uninstall package response");
 var EnablePackageRequestSchema = zod.z.object({
   /** Package ID to enable */
-  id: zod.z.string()
-});
+  id: zod.z.string().describe("Package ID to enable")
+}).describe("Enable package request");
 var EnablePackageResponseSchema = zod.z.object({
-  package: InstalledPackageSchema,
-  message: zod.z.string().optional()
-});
+  package: InstalledPackageSchema.describe("Enabled package details"),
+  message: zod.z.string().optional().describe("Enable status message")
+}).describe("Enable package response");
 var DisablePackageRequestSchema = zod.z.object({
   /** Package ID to disable */
-  id: zod.z.string()
-});
+  id: zod.z.string().describe("Package ID to disable")
+}).describe("Disable package request");
 var DisablePackageResponseSchema = zod.z.object({
-  package: InstalledPackageSchema,
-  message: zod.z.string().optional()
-});
+  package: InstalledPackageSchema.describe("Disabled package details"),
+  message: zod.z.string().optional().describe("Disable status message")
+}).describe("Disable package response");
 
 // src/api/protocol.zod.ts
 var AutomationTriggerRequestSchema = zod.z.object({
@@ -4772,7 +4936,8 @@ var GetDiscoveryResponseSchema = zod.z.object({
   version: zod.z.string().describe('API version (e.g., "v1", "2024-01")'),
   apiName: zod.z.string().describe("API name"),
   routes: ApiRoutesSchema.optional().describe("Available endpoint paths"),
-  services: zod.z.record(zod.z.string(), ServiceInfoSchema).optional().describe("Per-service availability map")
+  services: zod.z.record(zod.z.string(), ServiceInfoSchema).optional().describe("Per-service availability map"),
+  capabilities: WellKnownCapabilitiesSchema.optional().describe("Well-known capability flags for frontend adaptation")
 });
 var GetMetaTypesRequestSchema = zod.z.object({});
 var GetMetaTypesResponseSchema = zod.z.object({
@@ -4822,6 +4987,7 @@ var FindDataResponseSchema = zod.z.object({
   object: zod.z.string().describe("The object name for the returned records."),
   records: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown())).describe("The list of matching records."),
   total: zod.z.number().optional().describe("Total number of records matching the filter (if requested)."),
+  nextCursor: zod.z.string().optional().describe("Cursor for the next page of results (cursor-based pagination)."),
   hasMore: zod.z.boolean().optional().describe("True if there are more records available (pagination).")
 });
 var GetDataRequestSchema = zod.z.object({
@@ -5296,7 +5462,22 @@ var ObjectStackProtocolSchema = zod.z.object({
   // i18n Operations
   getLocales: zod.z.function().describe("Get available locales"),
   getTranslations: zod.z.function().describe("Get translations for a locale"),
-  getFieldLabels: zod.z.function().describe("Get translated field labels for an object")
+  getFieldLabels: zod.z.function().describe("Get translated field labels for an object"),
+  // Feed Operations
+  listFeed: zod.z.function().describe("List feed items for a record"),
+  createFeedItem: zod.z.function().describe("Create a new feed item"),
+  updateFeedItem: zod.z.function().describe("Update an existing feed item"),
+  deleteFeedItem: zod.z.function().describe("Delete a feed item"),
+  addReaction: zod.z.function().describe("Add an emoji reaction to a feed item"),
+  removeReaction: zod.z.function().describe("Remove an emoji reaction from a feed item"),
+  pinFeedItem: zod.z.function().describe("Pin a feed item"),
+  unpinFeedItem: zod.z.function().describe("Unpin a feed item"),
+  starFeedItem: zod.z.function().describe("Star a feed item"),
+  unstarFeedItem: zod.z.function().describe("Unstar a feed item"),
+  searchFeed: zod.z.function().describe("Search feed items"),
+  getChangelog: zod.z.function().describe("Get field-level changelog for a record"),
+  feedSubscribe: zod.z.function().describe("Subscribe to record notifications"),
+  feedUnsubscribe: zod.z.function().describe("Unsubscribe from record notifications")
 });
 var RestApiConfigSchema = zod.z.object({
   /**
@@ -7054,6 +7235,113 @@ var PresignedUrlResponseSchema = BaseResponseSchema.extend({
 var FileUploadResponseSchema = BaseResponseSchema.extend({
   data: FileMetadataSchema.describe("Uploaded file metadata")
 });
+var FileTypeValidationSchema = zod.z.object({
+  mode: zod.z.enum(["whitelist", "blacklist"]).describe("whitelist = only allow listed types, blacklist = block listed types"),
+  mimeTypes: zod.z.array(zod.z.string()).min(1).describe('List of MIME types to allow or block (e.g., "image/jpeg", "application/pdf")'),
+  extensions: zod.z.array(zod.z.string()).optional().describe('List of file extensions to allow or block (e.g., ".jpg", ".pdf")'),
+  maxFileSize: zod.z.number().int().min(1).optional().describe("Maximum file size in bytes"),
+  minFileSize: zod.z.number().int().min(0).optional().describe("Minimum file size in bytes (e.g., reject empty files)")
+});
+var InitiateChunkedUploadRequestSchema = zod.z.object({
+  filename: zod.z.string().describe("Original filename"),
+  mimeType: zod.z.string().describe("File MIME type"),
+  totalSize: zod.z.number().int().min(1).describe("Total file size in bytes"),
+  chunkSize: zod.z.number().int().min(5242880).default(5242880).describe("Size of each chunk in bytes (minimum 5MB per S3 spec)"),
+  scope: zod.z.string().default("user").describe("Target storage scope"),
+  bucket: zod.z.string().optional().describe("Specific bucket override (admin only)"),
+  metadata: zod.z.record(zod.z.string(), zod.z.string()).optional().describe("Custom metadata key-value pairs")
+});
+var InitiateChunkedUploadResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    uploadId: zod.z.string().describe("Multipart upload session ID"),
+    resumeToken: zod.z.string().describe("Opaque token for resuming interrupted uploads"),
+    fileId: zod.z.string().describe("Assigned file ID"),
+    totalChunks: zod.z.number().int().min(1).describe("Expected number of chunks"),
+    chunkSize: zod.z.number().int().describe("Chunk size in bytes"),
+    expiresAt: zod.z.string().datetime().describe("Upload session expiration timestamp")
+  })
+});
+var UploadChunkRequestSchema = zod.z.object({
+  uploadId: zod.z.string().describe("Multipart upload session ID"),
+  chunkIndex: zod.z.number().int().min(0).describe("Zero-based chunk index"),
+  resumeToken: zod.z.string().describe("Resume token from initiate response")
+});
+var UploadChunkResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    chunkIndex: zod.z.number().int().describe("Chunk index that was uploaded"),
+    eTag: zod.z.string().describe("Chunk ETag for multipart completion"),
+    bytesReceived: zod.z.number().int().describe("Bytes received for this chunk")
+  })
+});
+var CompleteChunkedUploadRequestSchema = zod.z.object({
+  uploadId: zod.z.string().describe("Multipart upload session ID"),
+  parts: zod.z.array(zod.z.object({
+    chunkIndex: zod.z.number().int().describe("Chunk index"),
+    eTag: zod.z.string().describe("ETag returned from chunk upload")
+  })).min(1).describe("Ordered list of uploaded parts for assembly")
+});
+var CompleteChunkedUploadResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    fileId: zod.z.string().describe("Final file ID"),
+    key: zod.z.string().describe("Storage key/path of the assembled file"),
+    size: zod.z.number().int().describe("Total file size in bytes"),
+    mimeType: zod.z.string().describe("File MIME type"),
+    eTag: zod.z.string().optional().describe("Final ETag of the assembled file"),
+    url: zod.z.string().optional().describe("Download URL for the assembled file")
+  })
+});
+var UploadProgressSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    uploadId: zod.z.string().describe("Multipart upload session ID"),
+    fileId: zod.z.string().describe("Assigned file ID"),
+    filename: zod.z.string().describe("Original filename"),
+    totalSize: zod.z.number().int().describe("Total file size in bytes"),
+    uploadedSize: zod.z.number().int().describe("Bytes uploaded so far"),
+    totalChunks: zod.z.number().int().describe("Total expected chunks"),
+    uploadedChunks: zod.z.number().int().describe("Number of chunks uploaded"),
+    percentComplete: zod.z.number().min(0).max(100).describe("Upload progress percentage"),
+    status: zod.z.enum(["in_progress", "completing", "completed", "failed", "expired"]).describe("Current upload session status"),
+    startedAt: zod.z.string().datetime().describe("Upload session start timestamp"),
+    expiresAt: zod.z.string().datetime().describe("Session expiration timestamp")
+  })
+});
+var StorageApiContracts = {
+  getPresignedUrl: {
+    method: "POST",
+    path: "/api/v1/storage/upload/presigned",
+    input: GetPresignedUrlRequestSchema,
+    output: PresignedUrlResponseSchema
+  },
+  completeUpload: {
+    method: "POST",
+    path: "/api/v1/storage/upload/complete",
+    input: CompleteUploadRequestSchema,
+    output: FileUploadResponseSchema
+  },
+  initiateChunkedUpload: {
+    method: "POST",
+    path: "/api/v1/storage/upload/chunked",
+    input: InitiateChunkedUploadRequestSchema,
+    output: InitiateChunkedUploadResponseSchema
+  },
+  uploadChunk: {
+    method: "PUT",
+    path: "/api/v1/storage/upload/chunked/:uploadId/chunk/:chunkIndex",
+    input: UploadChunkRequestSchema,
+    output: UploadChunkResponseSchema
+  },
+  completeChunkedUpload: {
+    method: "POST",
+    path: "/api/v1/storage/upload/chunked/:uploadId/complete",
+    input: CompleteChunkedUploadRequestSchema,
+    output: CompleteChunkedUploadResponseSchema
+  },
+  getUploadProgress: {
+    method: "GET",
+    path: "/api/v1/storage/upload/chunked/:uploadId/progress",
+    output: UploadProgressSchema
+  }
+};
 var EncryptionAlgorithmSchema = zod.z.enum([
   "aes-256-gcm",
   "aes-256-cbc",
@@ -10697,6 +10985,12 @@ var FeedItemSchema = zod.z.object({
   /** Reply threading */
   parentId: zod.z.string().optional().describe("Parent feed item ID for threaded replies"),
   replyCount: zod.z.number().int().min(0).default(0).describe("Number of replies"),
+  /** Pin / Star */
+  pinned: zod.z.boolean().default(false).describe("Whether the feed item is pinned to the top of the timeline"),
+  pinnedAt: zod.z.string().datetime().optional().describe("Timestamp when the item was pinned"),
+  pinnedBy: zod.z.string().optional().describe("User ID who pinned the item"),
+  starred: zod.z.boolean().default(false).describe("Whether the feed item is starred/bookmarked by the current user"),
+  starredAt: zod.z.string().datetime().optional().describe("Timestamp when the item was starred"),
   /** Visibility */
   visibility: FeedVisibility.default("public").describe("Visibility: public (all users), internal (team only), private (author + mentioned)"),
   /** Timestamps */
@@ -10808,6 +11102,85 @@ var RemoveReactionResponseSchema = BaseResponseSchema.extend({
     reactions: zod.z.array(ReactionSchema).describe("Updated reaction list for the feed item")
   })
 });
+var PinFeedItemRequestSchema = FeedItemPathParamsSchema;
+var PinFeedItemResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    feedId: zod.z.string().describe("ID of the pinned feed item"),
+    pinned: zod.z.boolean().describe("Whether the item is now pinned"),
+    pinnedAt: zod.z.string().datetime().describe("Timestamp when pinned")
+  })
+});
+var UnpinFeedItemRequestSchema = FeedItemPathParamsSchema;
+var UnpinFeedItemResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    feedId: zod.z.string().describe("ID of the unpinned feed item"),
+    pinned: zod.z.boolean().describe("Whether the item is now pinned (should be false)")
+  })
+});
+var StarFeedItemRequestSchema = FeedItemPathParamsSchema;
+var StarFeedItemResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    feedId: zod.z.string().describe("ID of the starred feed item"),
+    starred: zod.z.boolean().describe("Whether the item is now starred"),
+    starredAt: zod.z.string().datetime().describe("Timestamp when starred")
+  })
+});
+var UnstarFeedItemRequestSchema = FeedItemPathParamsSchema;
+var UnstarFeedItemResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    feedId: zod.z.string().describe("ID of the unstarred feed item"),
+    starred: zod.z.boolean().describe("Whether the item is now starred (should be false)")
+  })
+});
+var SearchFeedRequestSchema = FeedPathParamsSchema.extend({
+  query: zod.z.string().min(1).describe("Full-text search query against feed body content"),
+  type: FeedListFilterType.optional().describe("Filter by feed item category"),
+  actorId: zod.z.string().optional().describe("Filter by actor user ID"),
+  dateFrom: zod.z.string().datetime().optional().describe("Filter feed items created after this timestamp"),
+  dateTo: zod.z.string().datetime().optional().describe("Filter feed items created before this timestamp"),
+  hasAttachments: zod.z.boolean().optional().describe("Filter for items with file attachments"),
+  pinnedOnly: zod.z.boolean().optional().describe("Return only pinned items"),
+  starredOnly: zod.z.boolean().optional().describe("Return only starred items"),
+  limit: zod.z.number().int().min(1).max(100).default(20).describe("Maximum number of items to return"),
+  cursor: zod.z.string().optional().describe("Cursor for pagination")
+});
+var SearchFeedResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    items: zod.z.array(FeedItemSchema).describe("Matching feed items sorted by relevance"),
+    total: zod.z.number().int().optional().describe("Total matching items"),
+    nextCursor: zod.z.string().optional().describe("Cursor for the next page"),
+    hasMore: zod.z.boolean().describe("Whether more items are available")
+  })
+});
+var GetChangelogRequestSchema = FeedPathParamsSchema.extend({
+  field: zod.z.string().optional().describe("Filter changelog to a specific field name"),
+  actorId: zod.z.string().optional().describe("Filter changelog by actor user ID"),
+  dateFrom: zod.z.string().datetime().optional().describe("Filter changes after this timestamp"),
+  dateTo: zod.z.string().datetime().optional().describe("Filter changes before this timestamp"),
+  limit: zod.z.number().int().min(1).max(200).default(50).describe("Maximum number of changelog entries to return"),
+  cursor: zod.z.string().optional().describe("Cursor for pagination")
+});
+var ChangelogEntrySchema = zod.z.object({
+  id: zod.z.string().describe("Changelog entry ID"),
+  object: zod.z.string().describe("Object name"),
+  recordId: zod.z.string().describe("Record ID"),
+  actor: zod.z.object({
+    type: zod.z.enum(["user", "system", "service", "automation"]).describe("Actor type"),
+    id: zod.z.string().describe("Actor ID"),
+    name: zod.z.string().optional().describe("Actor display name")
+  }).describe("Who made the change"),
+  changes: zod.z.array(FieldChangeEntrySchema).min(1).describe("Field-level changes"),
+  timestamp: zod.z.string().datetime().describe("When the change occurred"),
+  source: zod.z.string().optional().describe('Change source (e.g., "API", "UI", "automation")')
+});
+var GetChangelogResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    entries: zod.z.array(ChangelogEntrySchema).describe("Changelog entries in reverse chronological order"),
+    total: zod.z.number().int().optional().describe("Total changelog entries matching filter"),
+    nextCursor: zod.z.string().optional().describe("Cursor for the next page"),
+    hasMore: zod.z.boolean().describe("Whether more entries are available")
+  })
+});
 var SubscribeRequestSchema = FeedPathParamsSchema.extend({
   events: zod.z.array(SubscriptionEventType).default(["all"]).describe("Event types to subscribe to"),
   channels: zod.z.array(NotificationChannel).default(["in_app"]).describe("Notification delivery channels")
@@ -10832,7 +11205,12 @@ var FeedApiErrorCode = zod.z.enum([
   "reaction_not_found",
   "subscription_already_exists",
   "subscription_not_found",
-  "invalid_feed_type"
+  "invalid_feed_type",
+  "feed_already_pinned",
+  "feed_not_pinned",
+  "feed_already_starred",
+  "feed_not_starred",
+  "feed_search_query_too_short"
 ]);
 var FeedApiContracts = {
   listFeed: {
@@ -10871,6 +11249,42 @@ var FeedApiContracts = {
     input: RemoveReactionRequestSchema,
     output: RemoveReactionResponseSchema
   },
+  pinFeedItem: {
+    method: "POST",
+    path: "/api/data/:object/:recordId/feed/:feedId/pin",
+    input: PinFeedItemRequestSchema,
+    output: PinFeedItemResponseSchema
+  },
+  unpinFeedItem: {
+    method: "DELETE",
+    path: "/api/data/:object/:recordId/feed/:feedId/pin",
+    input: UnpinFeedItemRequestSchema,
+    output: UnpinFeedItemResponseSchema
+  },
+  starFeedItem: {
+    method: "POST",
+    path: "/api/data/:object/:recordId/feed/:feedId/star",
+    input: StarFeedItemRequestSchema,
+    output: StarFeedItemResponseSchema
+  },
+  unstarFeedItem: {
+    method: "DELETE",
+    path: "/api/data/:object/:recordId/feed/:feedId/star",
+    input: UnstarFeedItemRequestSchema,
+    output: UnstarFeedItemResponseSchema
+  },
+  searchFeed: {
+    method: "GET",
+    path: "/api/data/:object/:recordId/feed/search",
+    input: SearchFeedRequestSchema,
+    output: SearchFeedResponseSchema
+  },
+  getChangelog: {
+    method: "GET",
+    path: "/api/data/:object/:recordId/changelog",
+    input: GetChangelogRequestSchema,
+    output: GetChangelogResponseSchema
+  },
   subscribe: {
     method: "POST",
     path: "/api/data/:object/:recordId/subscribe",
@@ -10884,6 +11298,1483 @@ var FeedApiContracts = {
     output: UnsubscribeResponseSchema
   }
 };
+var ExportFormat = zod.z.enum([
+  "csv",
+  "json",
+  "jsonl",
+  "xlsx",
+  "parquet"
+]);
+var ExportJobStatus = zod.z.enum([
+  "pending",
+  "processing",
+  "completed",
+  "failed",
+  "cancelled",
+  "expired"
+]);
+var CreateExportJobRequestSchema = zod.z.object({
+  object: zod.z.string().describe("Object name to export"),
+  format: ExportFormat.default("csv").describe("Export file format"),
+  fields: zod.z.array(zod.z.string()).optional().describe("Specific fields to include (omit for all fields)"),
+  filter: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Filter criteria for records to export"),
+  sort: zod.z.array(zod.z.object({
+    field: zod.z.string().describe("Field name to sort by"),
+    direction: zod.z.enum(["asc", "desc"]).default("asc").describe("Sort direction")
+  })).optional().describe("Sort order for exported records"),
+  limit: zod.z.number().int().min(1).optional().describe("Maximum number of records to export"),
+  includeHeaders: zod.z.boolean().default(true).describe("Include header row (CSV/XLSX)"),
+  encoding: zod.z.string().default("utf-8").describe("Character encoding for the export file"),
+  templateId: zod.z.string().optional().describe("Export template ID for predefined field mappings")
+});
+var CreateExportJobResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    jobId: zod.z.string().describe("Export job ID"),
+    status: ExportJobStatus.describe("Initial job status"),
+    estimatedRecords: zod.z.number().int().optional().describe("Estimated total records"),
+    createdAt: zod.z.string().datetime().describe("Job creation timestamp")
+  })
+});
+var ExportJobProgressSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    jobId: zod.z.string().describe("Export job ID"),
+    status: ExportJobStatus.describe("Current job status"),
+    format: ExportFormat.describe("Export format"),
+    totalRecords: zod.z.number().int().optional().describe("Total records to export"),
+    processedRecords: zod.z.number().int().describe("Records processed so far"),
+    percentComplete: zod.z.number().min(0).max(100).describe("Export progress percentage"),
+    fileSize: zod.z.number().int().optional().describe("Current file size in bytes"),
+    downloadUrl: zod.z.string().optional().describe('Presigned download URL (available when status is "completed")'),
+    downloadExpiresAt: zod.z.string().datetime().optional().describe("Download URL expiration timestamp"),
+    error: zod.z.object({
+      code: zod.z.string().describe("Error code"),
+      message: zod.z.string().describe("Error message")
+    }).optional().describe("Error details if job failed"),
+    startedAt: zod.z.string().datetime().optional().describe("Processing start timestamp"),
+    completedAt: zod.z.string().datetime().optional().describe("Completion timestamp")
+  })
+});
+var ImportValidationMode = zod.z.enum([
+  "strict",
+  // Reject entire import on any validation error
+  "lenient",
+  // Skip invalid records, import valid ones
+  "dry_run"
+  // Validate all records without persisting
+]);
+var DeduplicationStrategy = zod.z.enum([
+  "skip",
+  // Skip duplicates (keep existing)
+  "update",
+  // Update existing with import data
+  "create_new",
+  // Create new record even if duplicate
+  "fail"
+  // Fail the import if duplicates found
+]);
+var ImportValidationConfigSchema = zod.z.object({
+  mode: ImportValidationMode.default("strict").describe("Validation mode for the import"),
+  deduplication: zod.z.object({
+    strategy: DeduplicationStrategy.default("skip").describe("How to handle duplicate records"),
+    matchFields: zod.z.array(zod.z.string()).min(1).describe('Fields used to identify duplicates (e.g., "email", "external_id")')
+  }).optional().describe("Deduplication configuration"),
+  maxErrors: zod.z.number().int().min(1).default(100).describe("Maximum validation errors before aborting"),
+  trimWhitespace: zod.z.boolean().default(true).describe("Trim leading/trailing whitespace from string fields"),
+  dateFormat: zod.z.string().optional().describe('Expected date format in import data (e.g., "YYYY-MM-DD")'),
+  nullValues: zod.z.array(zod.z.string()).optional().describe('Strings to treat as null (e.g., ["", "N/A", "null"])')
+});
+var ImportValidationResultSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    totalRecords: zod.z.number().int().describe("Total records in import file"),
+    validRecords: zod.z.number().int().describe("Records that passed validation"),
+    invalidRecords: zod.z.number().int().describe("Records that failed validation"),
+    duplicateRecords: zod.z.number().int().describe("Duplicate records detected"),
+    errors: zod.z.array(zod.z.object({
+      row: zod.z.number().int().describe("Row number in the import file"),
+      field: zod.z.string().optional().describe("Field that failed validation"),
+      code: zod.z.string().describe("Validation error code"),
+      message: zod.z.string().describe("Validation error message")
+    })).describe("List of validation errors"),
+    preview: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown())).optional().describe("Preview of first N valid records (for dry_run mode)")
+  })
+});
+var FieldMappingEntrySchema = zod.z.object({
+  sourceField: zod.z.string().describe("Field name in the source data (import) or object (export)"),
+  targetField: zod.z.string().describe("Field name in the target object (import) or file column (export)"),
+  targetLabel: zod.z.string().optional().describe("Display label for the target column (export)"),
+  transform: zod.z.enum(["none", "uppercase", "lowercase", "trim", "date_format", "lookup"]).default("none").describe("Transformation to apply during mapping"),
+  defaultValue: zod.z.unknown().optional().describe("Default value if source field is null/empty"),
+  required: zod.z.boolean().default(false).describe("Whether this field is required (import validation)")
+});
+var ExportImportTemplateSchema = zod.z.object({
+  id: zod.z.string().optional().describe("Template ID (generated on save)"),
+  name: zod.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Template machine name (snake_case)"),
+  label: zod.z.string().describe("Human-readable template label"),
+  description: zod.z.string().optional().describe("Template description"),
+  object: zod.z.string().describe("Target object name"),
+  direction: zod.z.enum(["import", "export", "bidirectional"]).describe("Template direction"),
+  format: ExportFormat.optional().describe("Default file format for this template"),
+  mappings: zod.z.array(FieldMappingEntrySchema).min(1).describe("Field mapping entries"),
+  createdAt: zod.z.string().datetime().optional().describe("Template creation timestamp"),
+  updatedAt: zod.z.string().datetime().optional().describe("Last update timestamp"),
+  createdBy: zod.z.string().optional().describe("User who created the template")
+});
+var ScheduledExportSchema = zod.z.object({
+  id: zod.z.string().optional().describe("Scheduled export ID"),
+  name: zod.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Schedule name (snake_case)"),
+  label: zod.z.string().optional().describe("Human-readable label"),
+  object: zod.z.string().describe("Object name to export"),
+  format: ExportFormat.default("csv").describe("Export file format"),
+  fields: zod.z.array(zod.z.string()).optional().describe("Fields to include"),
+  filter: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Record filter criteria"),
+  templateId: zod.z.string().optional().describe("Export template ID for field mappings"),
+  schedule: zod.z.object({
+    cronExpression: zod.z.string().describe("Cron expression for schedule"),
+    timezone: zod.z.string().default("UTC").describe("IANA timezone")
+  }).describe("Schedule timing configuration"),
+  delivery: zod.z.object({
+    method: zod.z.enum(["email", "storage", "webhook"]).describe("How to deliver the export file"),
+    recipients: zod.z.array(zod.z.string()).optional().describe("Email recipients (for email delivery)"),
+    storagePath: zod.z.string().optional().describe("Storage path (for storage delivery)"),
+    webhookUrl: zod.z.string().optional().describe("Webhook URL (for webhook delivery)")
+  }).describe("Export delivery configuration"),
+  enabled: zod.z.boolean().default(true).describe("Whether the scheduled export is active"),
+  lastRunAt: zod.z.string().datetime().optional().describe("Last execution timestamp"),
+  nextRunAt: zod.z.string().datetime().optional().describe("Next scheduled execution"),
+  createdAt: zod.z.string().datetime().optional().describe("Creation timestamp"),
+  createdBy: zod.z.string().optional().describe("User who created the schedule")
+});
+var GetExportJobDownloadRequestSchema = zod.z.object({
+  jobId: zod.z.string().describe("Export job ID")
+});
+var GetExportJobDownloadResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    jobId: zod.z.string().describe("Export job ID"),
+    downloadUrl: zod.z.string().describe("Presigned download URL"),
+    fileName: zod.z.string().describe("Suggested file name"),
+    fileSize: zod.z.number().int().describe("File size in bytes"),
+    format: ExportFormat.describe("Export file format"),
+    expiresAt: zod.z.string().datetime().describe("Download URL expiration timestamp"),
+    checksum: zod.z.string().optional().describe("File checksum (SHA-256)")
+  })
+});
+var ListExportJobsRequestSchema = zod.z.object({
+  object: zod.z.string().optional().describe("Filter by object name"),
+  status: ExportJobStatus.optional().describe("Filter by job status"),
+  limit: zod.z.number().int().min(1).max(100).default(20).describe("Maximum number of jobs to return"),
+  cursor: zod.z.string().optional().describe("Pagination cursor from a previous response")
+});
+var ExportJobSummarySchema = zod.z.object({
+  jobId: zod.z.string().describe("Export job ID"),
+  object: zod.z.string().describe("Object name that was exported"),
+  status: ExportJobStatus.describe("Current job status"),
+  format: ExportFormat.describe("Export file format"),
+  totalRecords: zod.z.number().int().optional().describe("Total records exported"),
+  fileSize: zod.z.number().int().optional().describe("File size in bytes"),
+  createdAt: zod.z.string().datetime().describe("Job creation timestamp"),
+  completedAt: zod.z.string().datetime().optional().describe("Completion timestamp"),
+  createdBy: zod.z.string().optional().describe("User who initiated the export")
+});
+var ListExportJobsResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    jobs: zod.z.array(ExportJobSummarySchema).describe("List of export jobs"),
+    nextCursor: zod.z.string().optional().describe("Cursor for the next page"),
+    hasMore: zod.z.boolean().describe("Whether more jobs are available")
+  })
+});
+var ScheduleExportRequestSchema = zod.z.object({
+  name: zod.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Schedule name (snake_case)"),
+  label: zod.z.string().optional().describe("Human-readable label"),
+  object: zod.z.string().describe("Object name to export"),
+  format: ExportFormat.default("csv").describe("Export file format"),
+  fields: zod.z.array(zod.z.string()).optional().describe("Fields to include"),
+  filter: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Record filter criteria"),
+  templateId: zod.z.string().optional().describe("Export template ID for field mappings"),
+  schedule: zod.z.object({
+    cronExpression: zod.z.string().describe("Cron expression for schedule"),
+    timezone: zod.z.string().default("UTC").describe("IANA timezone")
+  }).describe("Schedule timing configuration"),
+  delivery: zod.z.object({
+    method: zod.z.enum(["email", "storage", "webhook"]).describe("How to deliver the export file"),
+    recipients: zod.z.array(zod.z.string()).optional().describe("Email recipients (for email delivery)"),
+    storagePath: zod.z.string().optional().describe("Storage path (for storage delivery)"),
+    webhookUrl: zod.z.string().optional().describe("Webhook URL (for webhook delivery)")
+  }).describe("Export delivery configuration")
+});
+var ScheduleExportResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    id: zod.z.string().describe("Scheduled export ID"),
+    name: zod.z.string().describe("Schedule name"),
+    enabled: zod.z.boolean().describe("Whether the schedule is active"),
+    nextRunAt: zod.z.string().datetime().optional().describe("Next scheduled execution"),
+    createdAt: zod.z.string().datetime().describe("Creation timestamp")
+  })
+});
+var ExportApiContracts = {
+  createExportJob: {
+    method: "POST",
+    path: "/api/v1/data/:object/export",
+    input: CreateExportJobRequestSchema,
+    output: CreateExportJobResponseSchema
+  },
+  getExportJobProgress: {
+    method: "GET",
+    path: "/api/v1/data/export/:jobId",
+    input: zod.z.object({ jobId: zod.z.string() }),
+    output: ExportJobProgressSchema
+  },
+  getExportJobDownload: {
+    method: "GET",
+    path: "/api/v1/data/export/:jobId/download",
+    input: GetExportJobDownloadRequestSchema,
+    output: GetExportJobDownloadResponseSchema
+  },
+  listExportJobs: {
+    method: "GET",
+    path: "/api/v1/data/export",
+    input: ListExportJobsRequestSchema,
+    output: ListExportJobsResponseSchema
+  },
+  scheduleExport: {
+    method: "POST",
+    path: "/api/v1/data/export/schedules",
+    input: ScheduleExportRequestSchema,
+    output: ScheduleExportResponseSchema
+  },
+  cancelExportJob: {
+    method: "POST",
+    path: "/api/v1/data/export/:jobId/cancel",
+    input: zod.z.object({ jobId: zod.z.string() }),
+    output: BaseResponseSchema
+  }
+};
+var FlowNodeAction = zod.z.enum([
+  "start",
+  // Trigger
+  "end",
+  // Return/Stop
+  "decision",
+  // If/Else logic
+  "assignment",
+  // Set Variable
+  "loop",
+  // For Each
+  "create_record",
+  // CRUD: Create
+  "update_record",
+  // CRUD: Update
+  "delete_record",
+  // CRUD: Delete
+  "get_record",
+  // CRUD: Get/Query
+  "http_request",
+  // Webhook/API Call
+  "script",
+  // Custom Script (JS/TS)
+  "screen",
+  // Screen / User-Input Element
+  "wait",
+  // Delay/Sleep
+  "subflow",
+  // Call another flow
+  "connector_action",
+  // Zapier-style integration action
+  "parallel_gateway",
+  // BPMN Parallel Gateway — AND-split (all outgoing branches execute concurrently)
+  "join_gateway",
+  // BPMN Join Gateway — AND-join (waits for all incoming branches to complete)
+  "boundary_event"
+  // BPMN Boundary Event — attached to a host node for timer/error/signal interrupts
+]);
+var FlowVariableSchema = zod.z.object({
+  name: zod.z.string().describe("Variable name"),
+  type: zod.z.string().describe("Data type (text, number, boolean, object, list)"),
+  isInput: zod.z.boolean().default(false).describe("Is input parameter"),
+  isOutput: zod.z.boolean().default(false).describe("Is output parameter")
+});
+var FlowNodeSchema = zod.z.object({
+  id: zod.z.string().describe("Node unique ID"),
+  type: FlowNodeAction.describe("Action type"),
+  label: zod.z.string().describe("Node label"),
+  /** Node Configuration Options (Specific to type) */
+  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Node configuration"),
+  /** 
+   * Connector Action Configuration
+   * Used when type is 'connector_action'
+   */
+  connectorConfig: zod.z.object({
+    connectorId: zod.z.string(),
+    actionId: zod.z.string(),
+    input: zod.z.record(zod.z.string(), zod.z.unknown()).describe("Mapped inputs for the action")
+  }).optional(),
+  /** UI Position (for the canvas) */
+  position: zod.z.object({ x: zod.z.number(), y: zod.z.number() }).optional(),
+  /** Node-level execution timeout */
+  timeoutMs: zod.z.number().int().min(0).optional().describe("Maximum execution time for this node in milliseconds"),
+  /** Node input schema declaration for Studio form generation and runtime validation */
+  inputSchema: zod.z.record(zod.z.string(), zod.z.object({
+    type: zod.z.enum(["string", "number", "boolean", "object", "array"]).describe("Parameter type"),
+    required: zod.z.boolean().default(false).describe("Whether the parameter is required"),
+    description: zod.z.string().optional().describe("Parameter description")
+  })).optional().describe("Input parameter schema for this node"),
+  /** Node output schema declaration */
+  outputSchema: zod.z.record(zod.z.string(), zod.z.object({
+    type: zod.z.enum(["string", "number", "boolean", "object", "array"]).describe("Output type"),
+    description: zod.z.string().optional().describe("Output description")
+  })).optional().describe("Output schema declaration for this node"),
+  /**
+   * Wait Event Configuration (for 'wait' nodes)
+   * Defines what external event or condition should resume the paused execution.
+   * Industry alignment: BPMN Intermediate Catch Events, Temporal Signals.
+   */
+  waitEventConfig: zod.z.object({
+    /** Type of event to wait for */
+    eventType: zod.z.enum(["timer", "signal", "webhook", "manual", "condition"]).describe("What kind of event resumes the execution"),
+    /** Duration to wait (ISO 8601 duration or milliseconds) — for timer events */
+    timerDuration: zod.z.string().optional().describe('ISO 8601 duration (e.g., "PT1H") or wait time for timer events'),
+    /** Signal name to listen for — for signal/webhook events */
+    signalName: zod.z.string().optional().describe("Named signal or webhook event to wait for"),
+    /** Timeout before auto-failing or continuing — optional guard */
+    timeoutMs: zod.z.number().int().min(0).optional().describe("Maximum wait time before timeout (ms)"),
+    /** Action to take on timeout */
+    onTimeout: zod.z.enum(["fail", "continue"]).default("fail").describe("Behavior when the wait times out")
+  }).optional().describe("Configuration for wait node event resumption"),
+  /**
+   * Boundary Event Configuration (for 'boundary_event' nodes)
+   * Attaches an event handler to a host activity node (BPMN Boundary Event pattern).
+   * Industry alignment: BPMN Boundary Error/Timer/Signal Events.
+   */
+  boundaryConfig: zod.z.object({
+    /** ID of the host node this boundary event is attached to */
+    attachedToNodeId: zod.z.string().describe("Host node ID this boundary event monitors"),
+    /** Type of boundary event */
+    eventType: zod.z.enum(["error", "timer", "signal", "cancel"]).describe("Boundary event trigger type"),
+    /** Whether the boundary event interrupts the host activity */
+    interrupting: zod.z.boolean().default(true).describe("If true, the host activity is cancelled when this event fires"),
+    /** Error code filter — only for error boundary events */
+    errorCode: zod.z.string().optional().describe("Specific error code to catch (empty = catch all errors)"),
+    /** Timer duration — only for timer boundary events */
+    timerDuration: zod.z.string().optional().describe("ISO 8601 duration for timer boundary events"),
+    /** Signal name — only for signal boundary events */
+    signalName: zod.z.string().optional().describe("Named signal to catch")
+  }).optional().describe("Configuration for boundary events attached to host nodes")
+});
+var FlowEdgeSchema = zod.z.object({
+  id: zod.z.string().describe("Edge unique ID"),
+  source: zod.z.string().describe("Source Node ID"),
+  target: zod.z.string().describe("Target Node ID"),
+  /** Condition for this path (only for decision/branch nodes) */
+  condition: zod.z.string().optional().describe("Expression returning boolean used for branching"),
+  type: zod.z.enum(["default", "fault", "conditional"]).default("default").describe("Connection type: default (normal flow), fault (error path), or conditional (expression-guarded)"),
+  label: zod.z.string().optional().describe("Label on the connector"),
+  /**
+   * Default Sequence Flow marker (BPMN Default Flow semantics).
+   * When true, this edge is taken when no sibling conditional edges match.
+   * Only meaningful on outgoing edges of decision/gateway nodes.
+   */
+  isDefault: zod.z.boolean().default(false).describe("Marks this edge as the default path when no other conditions match")
+});
+var FlowSchema = zod.z.object({
+  /** Identity */
+  name: zod.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Machine name"),
+  label: zod.z.string().describe("Flow label"),
+  description: zod.z.string().optional(),
+  /** Metadata & Versioning */
+  version: zod.z.number().int().default(1).describe("Version number"),
+  status: zod.z.enum(["draft", "active", "obsolete", "invalid"]).default("draft").describe("Deployment status"),
+  template: zod.z.boolean().default(false).describe("Is logic template (Subflow)"),
+  /** Trigger Type */
+  type: zod.z.enum(["autolaunched", "record_change", "schedule", "screen", "api"]).describe("Flow type"),
+  /** Configuration Variables */
+  variables: zod.z.array(FlowVariableSchema).optional().describe("Flow variables"),
+  /** Graph Definition */
+  nodes: zod.z.array(FlowNodeSchema).describe("Flow nodes"),
+  edges: zod.z.array(FlowEdgeSchema).describe("Flow connections"),
+  /** Execution Config */
+  active: zod.z.boolean().default(false).describe("Is active (Deprecated: use status)"),
+  runAs: zod.z.enum(["system", "user"]).default("user").describe("Execution context"),
+  /** Error Handling Strategy */
+  errorHandling: zod.z.object({
+    strategy: zod.z.enum(["fail", "retry", "continue"]).default("fail").describe("How to handle node execution errors"),
+    maxRetries: zod.z.number().int().min(0).max(10).default(0).describe("Number of retry attempts (only for retry strategy)"),
+    retryDelayMs: zod.z.number().int().min(0).default(1e3).describe("Delay between retries in milliseconds"),
+    backoffMultiplier: zod.z.number().min(1).default(1).describe("Multiplier for exponential backoff between retries"),
+    maxRetryDelayMs: zod.z.number().int().min(0).default(3e4).describe("Maximum delay between retries in milliseconds"),
+    jitter: zod.z.boolean().default(false).describe("Add random jitter to retry delay to avoid thundering herd"),
+    fallbackNodeId: zod.z.string().optional().describe("Node ID to jump to on unrecoverable error")
+  }).optional().describe("Flow-level error handling configuration")
+});
+zod.z.object({
+  flowName: zod.z.string().describe("Flow machine name"),
+  version: zod.z.number().int().min(1).describe("Version number"),
+  definition: FlowSchema.describe("Complete flow definition snapshot"),
+  createdAt: zod.z.string().datetime().describe("When this version was created"),
+  createdBy: zod.z.string().optional().describe("User who created this version"),
+  changeNote: zod.z.string().optional().describe("Description of what changed in this version")
+});
+var ExecutionStatus = zod.z.enum([
+  "pending",
+  // Queued, not yet started
+  "running",
+  // Currently executing
+  "paused",
+  // Paused at a wait/checkpoint node
+  "completed",
+  // Successfully finished
+  "failed",
+  // Terminated with error
+  "cancelled",
+  // Manually cancelled
+  "timed_out",
+  // Exceeded max execution time
+  "retrying"
+  // Failed and retrying
+]);
+var ExecutionStepLogSchema = zod.z.object({
+  nodeId: zod.z.string().describe("Node ID that was executed"),
+  nodeType: zod.z.string().describe('Node action type (e.g., "decision", "http_request")'),
+  nodeLabel: zod.z.string().optional().describe("Human-readable node label"),
+  status: zod.z.enum(["success", "failure", "skipped"]).describe("Step execution result"),
+  startedAt: zod.z.string().datetime().describe("When the step started"),
+  completedAt: zod.z.string().datetime().optional().describe("When the step completed"),
+  durationMs: zod.z.number().int().min(0).optional().describe("Step execution duration in milliseconds"),
+  input: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Input data passed to the node"),
+  output: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Output data produced by the node"),
+  error: zod.z.object({
+    code: zod.z.string().describe("Error code"),
+    message: zod.z.string().describe("Error message"),
+    stack: zod.z.string().optional().describe("Stack trace")
+  }).optional().describe("Error details if step failed"),
+  retryAttempt: zod.z.number().int().min(0).optional().describe("Retry attempt number (0 = first try)")
+});
+var ExecutionLogSchema = zod.z.object({
+  /** Unique execution ID */
+  id: zod.z.string().describe("Execution instance ID"),
+  /** Flow reference */
+  flowName: zod.z.string().describe("Machine name of the executed flow"),
+  flowVersion: zod.z.number().int().optional().describe("Version of the flow that was executed"),
+  /** Execution status */
+  status: ExecutionStatus.describe("Current execution status"),
+  /** Trigger context */
+  trigger: zod.z.object({
+    type: zod.z.string().describe('Trigger type (e.g., "record_change", "schedule", "api", "manual")'),
+    recordId: zod.z.string().optional().describe("Triggering record ID"),
+    object: zod.z.string().optional().describe("Triggering object name"),
+    userId: zod.z.string().optional().describe("User who triggered the execution"),
+    metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Additional trigger context")
+  }).describe("What triggered this execution"),
+  /** Step-by-step execution history */
+  steps: zod.z.array(ExecutionStepLogSchema).describe("Ordered list of executed steps"),
+  /** Execution variables snapshot */
+  variables: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Final state of flow variables"),
+  /** Timing */
+  startedAt: zod.z.string().datetime().describe("Execution start timestamp"),
+  completedAt: zod.z.string().datetime().optional().describe("Execution completion timestamp"),
+  durationMs: zod.z.number().int().min(0).optional().describe("Total execution duration in milliseconds"),
+  /** Context */
+  runAs: zod.z.enum(["system", "user"]).optional().describe("Execution context identity"),
+  tenantId: zod.z.string().optional().describe("Tenant ID for multi-tenant isolation")
+});
+var ExecutionErrorSeverity = zod.z.enum([
+  "warning",
+  // Non-fatal issue (e.g., deprecated node type)
+  "error",
+  // Node-level failure (may be retried)
+  "critical"
+  // Flow-level failure (execution terminated)
+]);
+zod.z.object({
+  id: zod.z.string().describe("Error record ID"),
+  executionId: zod.z.string().describe("Parent execution ID"),
+  nodeId: zod.z.string().optional().describe("Node where the error occurred"),
+  severity: ExecutionErrorSeverity.describe("Error severity level"),
+  code: zod.z.string().describe("Machine-readable error code"),
+  message: zod.z.string().describe("Human-readable error message"),
+  stack: zod.z.string().optional().describe("Stack trace for debugging"),
+  context: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Additional diagnostic context (input data, config snapshot)"),
+  timestamp: zod.z.string().datetime().describe("When the error occurred"),
+  retryable: zod.z.boolean().default(false).describe("Whether this error can be retried"),
+  resolvedAt: zod.z.string().datetime().optional().describe("When the error was resolved (e.g., after successful retry)")
+});
+zod.z.object({
+  /** Unique checkpoint ID */
+  id: zod.z.string().describe("Checkpoint ID"),
+  /** Execution reference */
+  executionId: zod.z.string().describe("Parent execution ID"),
+  flowName: zod.z.string().describe("Flow machine name"),
+  /** State snapshot */
+  currentNodeId: zod.z.string().describe("Node ID where execution is paused"),
+  variables: zod.z.record(zod.z.string(), zod.z.unknown()).describe("Flow variable state at checkpoint"),
+  completedNodeIds: zod.z.array(zod.z.string()).describe("List of node IDs already executed"),
+  /** Timing */
+  createdAt: zod.z.string().datetime().describe("Checkpoint creation timestamp"),
+  expiresAt: zod.z.string().datetime().optional().describe("Checkpoint expiration (auto-cleanup)"),
+  /** Reason */
+  reason: zod.z.enum(["wait", "screen_input", "approval", "error", "manual_pause", "parallel_join", "boundary_event"]).describe("Why the execution was checkpointed")
+});
+zod.z.object({
+  /** Maximum concurrent executions of this flow */
+  maxConcurrent: zod.z.number().int().min(1).default(1).describe("Maximum number of concurrent executions allowed"),
+  /** What to do when max concurrency is reached */
+  onConflict: zod.z.enum(["queue", "reject", "cancel_existing"]).default("queue").describe("queue = enqueue for later, reject = fail immediately, cancel_existing = stop running instance"),
+  /** Lock scope for concurrency */
+  lockScope: zod.z.enum(["global", "per_record", "per_user"]).default("global").describe("Scope of the concurrency lock"),
+  /** Queue timeout (only when onConflict is "queue") */
+  queueTimeoutMs: zod.z.number().int().min(0).optional().describe("Maximum time to wait in queue before timing out (ms)")
+});
+zod.z.object({
+  /** Unique schedule ID */
+  id: zod.z.string().describe("Schedule instance ID"),
+  /** Flow reference */
+  flowName: zod.z.string().describe("Flow machine name"),
+  /** Schedule configuration */
+  cronExpression: zod.z.string().describe('Cron expression (e.g., "0 9 * * MON-FRI")'),
+  timezone: zod.z.string().default("UTC").describe("IANA timezone for cron evaluation"),
+  /** Runtime state */
+  status: zod.z.enum(["active", "paused", "disabled", "expired"]).default("active").describe("Current schedule status"),
+  nextRunAt: zod.z.string().datetime().optional().describe("Next scheduled execution timestamp"),
+  lastRunAt: zod.z.string().datetime().optional().describe("Last execution timestamp"),
+  lastExecutionId: zod.z.string().optional().describe("Execution ID of the last run"),
+  lastRunStatus: ExecutionStatus.optional().describe("Status of the last run"),
+  /** Execution tracking */
+  totalRuns: zod.z.number().int().min(0).default(0).describe("Total number of executions"),
+  consecutiveFailures: zod.z.number().int().min(0).default(0).describe("Consecutive failed executions"),
+  /** Bounds */
+  startDate: zod.z.string().datetime().optional().describe("Schedule effective start date"),
+  endDate: zod.z.string().datetime().optional().describe("Schedule expiration date"),
+  maxRuns: zod.z.number().int().min(1).optional().describe("Maximum total executions before auto-disable"),
+  /** Metadata */
+  createdAt: zod.z.string().datetime().describe("Schedule creation timestamp"),
+  updatedAt: zod.z.string().datetime().optional().describe("Last update timestamp"),
+  createdBy: zod.z.string().optional().describe("User who created the schedule")
+});
+
+// src/api/automation-api.zod.ts
+var AutomationFlowPathParamsSchema = zod.z.object({
+  name: zod.z.string().describe("Flow machine name (snake_case)")
+});
+var AutomationRunPathParamsSchema = AutomationFlowPathParamsSchema.extend({
+  runId: zod.z.string().describe("Execution run ID")
+});
+var ListFlowsRequestSchema = zod.z.object({
+  status: zod.z.enum(["draft", "active", "obsolete", "invalid"]).optional().describe("Filter by flow status"),
+  type: zod.z.enum(["autolaunched", "record_change", "schedule", "screen", "api"]).optional().describe("Filter by flow type"),
+  limit: zod.z.number().int().min(1).max(100).default(50).describe("Maximum number of flows to return"),
+  cursor: zod.z.string().optional().describe("Cursor for pagination")
+});
+var FlowSummarySchema = zod.z.object({
+  name: zod.z.string().describe("Flow machine name"),
+  label: zod.z.string().describe("Flow display label"),
+  type: zod.z.string().describe("Flow type"),
+  status: zod.z.string().describe("Flow deployment status"),
+  version: zod.z.number().int().describe("Flow version number"),
+  enabled: zod.z.boolean().describe("Whether the flow is enabled for execution"),
+  nodeCount: zod.z.number().int().optional().describe("Number of nodes in the flow"),
+  lastRunAt: zod.z.string().datetime().optional().describe("Last execution timestamp")
+});
+var ListFlowsResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    flows: zod.z.array(FlowSummarySchema).describe("Flow summaries"),
+    total: zod.z.number().int().optional().describe("Total matching flows"),
+    nextCursor: zod.z.string().optional().describe("Cursor for the next page"),
+    hasMore: zod.z.boolean().describe("Whether more flows are available")
+  })
+});
+var GetFlowRequestSchema = AutomationFlowPathParamsSchema;
+var GetFlowResponseSchema = BaseResponseSchema.extend({
+  data: FlowSchema.describe("Full flow definition")
+});
+var CreateFlowRequestSchema = FlowSchema;
+var CreateFlowResponseSchema = BaseResponseSchema.extend({
+  data: FlowSchema.describe("The created flow definition")
+});
+var UpdateFlowRequestSchema = AutomationFlowPathParamsSchema.extend({
+  definition: FlowSchema.partial().describe("Partial flow definition to update")
+});
+var UpdateFlowResponseSchema = BaseResponseSchema.extend({
+  data: FlowSchema.describe("The updated flow definition")
+});
+var DeleteFlowRequestSchema = AutomationFlowPathParamsSchema;
+var DeleteFlowResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    name: zod.z.string().describe("Name of the deleted flow"),
+    deleted: zod.z.boolean().describe("Whether the flow was deleted")
+  })
+});
+var TriggerFlowRequestSchema = AutomationFlowPathParamsSchema.extend({
+  record: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Record that triggered the automation"),
+  object: zod.z.string().optional().describe("Object name the record belongs to"),
+  event: zod.z.string().optional().describe("Trigger event type"),
+  userId: zod.z.string().optional().describe("User who triggered the automation"),
+  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Additional contextual data")
+});
+var TriggerFlowResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    success: zod.z.boolean().describe("Whether the automation completed successfully"),
+    output: zod.z.unknown().optional().describe("Output data from the automation"),
+    error: zod.z.string().optional().describe("Error message if execution failed"),
+    durationMs: zod.z.number().optional().describe("Execution duration in milliseconds")
+  })
+});
+var ToggleFlowRequestSchema = AutomationFlowPathParamsSchema.extend({
+  enabled: zod.z.boolean().describe("Whether to enable (true) or disable (false) the flow")
+});
+var ToggleFlowResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    name: zod.z.string().describe("Flow name"),
+    enabled: zod.z.boolean().describe("New enabled state")
+  })
+});
+var ListRunsRequestSchema = AutomationFlowPathParamsSchema.extend({
+  status: zod.z.enum(["pending", "running", "paused", "completed", "failed", "cancelled", "timed_out", "retrying"]).optional().describe("Filter by execution status"),
+  limit: zod.z.number().int().min(1).max(100).default(20).describe("Maximum number of runs to return"),
+  cursor: zod.z.string().optional().describe("Cursor for pagination")
+});
+var ListRunsResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    runs: zod.z.array(ExecutionLogSchema).describe("Execution run logs"),
+    total: zod.z.number().int().optional().describe("Total matching runs"),
+    nextCursor: zod.z.string().optional().describe("Cursor for the next page"),
+    hasMore: zod.z.boolean().describe("Whether more runs are available")
+  })
+});
+var GetRunRequestSchema = AutomationRunPathParamsSchema;
+var GetRunResponseSchema = BaseResponseSchema.extend({
+  data: ExecutionLogSchema.describe("Full execution log with step details")
+});
+var AutomationApiErrorCode = zod.z.enum([
+  "flow_not_found",
+  "flow_already_exists",
+  "flow_validation_failed",
+  "flow_disabled",
+  "execution_not_found",
+  "execution_failed",
+  "execution_timeout",
+  "node_executor_not_found",
+  "concurrent_execution_limit"
+]);
+var AutomationApiContracts = {
+  listFlows: {
+    method: "GET",
+    path: "/api/automation",
+    input: ListFlowsRequestSchema,
+    output: ListFlowsResponseSchema
+  },
+  getFlow: {
+    method: "GET",
+    path: "/api/automation/:name",
+    input: GetFlowRequestSchema,
+    output: GetFlowResponseSchema
+  },
+  createFlow: {
+    method: "POST",
+    path: "/api/automation",
+    input: CreateFlowRequestSchema,
+    output: CreateFlowResponseSchema
+  },
+  updateFlow: {
+    method: "PUT",
+    path: "/api/automation/:name",
+    input: UpdateFlowRequestSchema,
+    output: UpdateFlowResponseSchema
+  },
+  deleteFlow: {
+    method: "DELETE",
+    path: "/api/automation/:name",
+    input: DeleteFlowRequestSchema,
+    output: DeleteFlowResponseSchema
+  },
+  triggerFlow: {
+    method: "POST",
+    path: "/api/automation/:name/trigger",
+    input: TriggerFlowRequestSchema,
+    output: TriggerFlowResponseSchema
+  },
+  toggleFlow: {
+    method: "POST",
+    path: "/api/automation/:name/toggle",
+    input: ToggleFlowRequestSchema,
+    output: ToggleFlowResponseSchema
+  },
+  listRuns: {
+    method: "GET",
+    path: "/api/automation/:name/runs",
+    input: ListRunsRequestSchema,
+    output: ListRunsResponseSchema
+  },
+  getRun: {
+    method: "GET",
+    path: "/api/automation/:name/runs/:runId",
+    input: GetRunRequestSchema,
+    output: GetRunResponseSchema
+  }
+};
+var MetadataChangeTypeSchema = zod.z.enum([
+  "added",
+  // New metadata item added in new version
+  "modified",
+  // Existing metadata item modified
+  "removed",
+  // Metadata item removed in new version
+  "renamed"
+  // Metadata item renamed
+]).describe("Type of metadata change between package versions");
+var MetadataDiffItemSchema = zod.z.object({
+  /** Metadata type (e.g. "object", "view", "flow") */
+  type: zod.z.string().describe("Metadata type"),
+  /** Metadata name */
+  name: zod.z.string().describe("Metadata name"),
+  /** Type of change */
+  changeType: MetadataChangeTypeSchema.describe("Category of metadata modification (added, modified, removed, or renamed)"),
+  /** Whether this change has potential conflicts with customizations */
+  hasConflict: zod.z.boolean().default(false).describe("Whether this change may conflict with customizations"),
+  /** Human-readable summary of the change */
+  summary: zod.z.string().optional().describe("Human-readable change summary"),
+  /** Previous name (for renames) */
+  previousName: zod.z.string().optional().describe("Previous name if renamed")
+}).describe("Single metadata change between package versions");
+var UpgradeImpactLevelSchema = zod.z.enum([
+  "none",
+  // No impact, seamless upgrade
+  "low",
+  // Minor changes, no user action needed
+  "medium",
+  // Some changes that may affect workflows
+  "high",
+  // Significant changes, user review recommended
+  "critical"
+  // Breaking changes, manual intervention required
+]).describe("Severity of upgrade impact");
+var UpgradePlanSchema = zod.z.object({
+  /** Package being upgraded */
+  packageId: zod.z.string().describe("Package identifier"),
+  /** Current installed version */
+  fromVersion: zod.z.string().describe("Currently installed version"),
+  /** Target version to upgrade to */
+  toVersion: zod.z.string().describe("Target upgrade version"),
+  /** Overall impact level */
+  impactLevel: UpgradeImpactLevelSchema.describe("Severity assessment from none (seamless) to critical (breaking changes)"),
+  /** List of all metadata changes between versions */
+  changes: zod.z.array(MetadataDiffItemSchema).describe("All metadata changes"),
+  /** Number of customer customizations that may be affected */
+  affectedCustomizations: zod.z.number().int().min(0).default(0).describe("Count of customizations that may be affected"),
+  /** Whether any migration scripts need to run */
+  requiresMigration: zod.z.boolean().default(false).describe("Whether data migration scripts are needed"),
+  /** Migration script paths (relative to package root) */
+  migrationScripts: zod.z.array(zod.z.string()).optional().describe("Paths to migration scripts"),
+  /** Dependencies that also need upgrading */
+  dependencyUpgrades: zod.z.array(zod.z.object({
+    packageId: zod.z.string(),
+    fromVersion: zod.z.string(),
+    toVersion: zod.z.string()
+  })).optional().describe("Dependent packages that also need upgrading"),
+  /** Estimated upgrade duration in seconds */
+  estimatedDuration: zod.z.number().int().min(0).optional().describe("Estimated upgrade duration in seconds"),
+  /** Human-readable summary */
+  summary: zod.z.string().optional().describe("Human-readable upgrade summary")
+}).describe("Upgrade analysis plan generated before execution");
+zod.z.object({
+  /** Snapshot ID (UUID) */
+  id: zod.z.string().describe("Snapshot identifier"),
+  /** Package being upgraded */
+  packageId: zod.z.string().describe("Package identifier"),
+  /** Version being upgraded from */
+  fromVersion: zod.z.string().describe("Version before upgrade"),
+  /** Version being upgraded to */
+  toVersion: zod.z.string().describe("Target upgrade version"),
+  /** Tenant ID */
+  tenantId: zod.z.string().optional().describe("Tenant identifier"),
+  /** Complete manifest of the old package version */
+  previousManifest: ManifestSchema.describe("Complete manifest of the previous package version"),
+  /**
+   * Snapshot of all metadata records owned by this package.
+   * Stored as array of { type, name, metadata } tuples.
+   */
+  metadataSnapshot: zod.z.array(zod.z.object({
+    type: zod.z.string(),
+    name: zod.z.string(),
+    metadata: zod.z.record(zod.z.string(), zod.z.unknown())
+  })).describe("Snapshot of all package metadata"),
+  /**
+   * Snapshot of all customer customizations (overlays) for this package's metadata.
+   */
+  customizationSnapshot: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown())).optional().describe("Snapshot of customer customizations"),
+  /** When the snapshot was created */
+  createdAt: zod.z.string().datetime().describe("Snapshot creation timestamp"),
+  /** Expiry time for snapshot cleanup */
+  expiresAt: zod.z.string().datetime().optional().describe("Snapshot expiry timestamp")
+}).describe("Pre-upgrade state snapshot for rollback capability");
+zod.z.object({
+  /** Package ID to upgrade */
+  packageId: zod.z.string().describe("Package ID to upgrade"),
+  /** Target version (if omitted, upgrades to latest) */
+  targetVersion: zod.z.string().optional().describe("Target version (defaults to latest)"),
+  /** New manifest for the target version */
+  manifest: ManifestSchema.optional().describe("New manifest (if installing from local)"),
+  /** Whether to create a pre-upgrade snapshot */
+  createSnapshot: zod.z.boolean().default(true).describe("Whether to create a pre-upgrade backup snapshot"),
+  /** Merge strategy for handling customizations */
+  mergeStrategy: zod.z.enum([
+    "keep-custom",
+    "accept-incoming",
+    "three-way-merge"
+  ]).default("three-way-merge").describe("How to handle customer customizations"),
+  /** Whether to run in dry-run mode (preview only, no changes) */
+  dryRun: zod.z.boolean().default(false).describe("Preview upgrade without making changes"),
+  /** Whether to skip pre-upgrade validation */
+  skipValidation: zod.z.boolean().default(false).describe("Skip pre-upgrade compatibility checks")
+}).describe("Upgrade package request");
+var UpgradePhaseSchema = zod.z.enum([
+  "pending",
+  // Upgrade requested but not started
+  "analyzing",
+  // Generating upgrade plan
+  "snapshot",
+  // Creating pre-upgrade snapshot
+  "executing",
+  // Applying metadata changes
+  "migrating",
+  // Running migration scripts
+  "validating",
+  // Post-upgrade validation
+  "completed",
+  // Upgrade completed successfully
+  "failed",
+  // Upgrade failed
+  "rolling-back",
+  // Rollback in progress
+  "rolled-back"
+  // Rollback completed
+]).describe("Current phase of the upgrade process");
+zod.z.object({
+  /** Whether the upgrade was successful */
+  success: zod.z.boolean().describe("Whether the upgrade succeeded"),
+  /** Current upgrade phase */
+  phase: UpgradePhaseSchema.describe("Current upgrade phase"),
+  /** The upgrade plan that was executed */
+  plan: UpgradePlanSchema.optional().describe("Upgrade plan"),
+  /** Snapshot ID for rollback */
+  snapshotId: zod.z.string().optional().describe("Snapshot ID for rollback"),
+  /** Merge conflicts that need manual resolution (if any) */
+  conflicts: zod.z.array(zod.z.object({
+    path: zod.z.string(),
+    baseValue: zod.z.unknown(),
+    incomingValue: zod.z.unknown(),
+    customValue: zod.z.unknown()
+  })).optional().describe("Unresolved merge conflicts"),
+  /** Error message (if failed) */
+  errorMessage: zod.z.string().optional().describe("Error message if upgrade failed"),
+  /** Human-readable summary */
+  message: zod.z.string().optional().describe("Human-readable status message")
+}).describe("Upgrade package response");
+zod.z.object({
+  /** Package ID to rollback */
+  packageId: zod.z.string().describe("Package ID to rollback"),
+  /** Snapshot ID to restore from */
+  snapshotId: zod.z.string().describe("Snapshot ID to restore from"),
+  /** Whether to also rollback customizations */
+  rollbackCustomizations: zod.z.boolean().default(true).describe("Whether to restore pre-upgrade customizations")
+}).describe("Rollback package request");
+zod.z.object({
+  /** Whether the rollback was successful */
+  success: zod.z.boolean().describe("Whether the rollback succeeded"),
+  /** Restored version */
+  restoredVersion: zod.z.string().optional().describe("Version restored to"),
+  /** Message */
+  message: zod.z.string().optional().describe("Rollback status message")
+}).describe("Rollback package response");
+var MetadataCategoryEnum = zod.z.enum([
+  "objects",
+  "views",
+  "pages",
+  "flows",
+  "dashboards",
+  "permissions",
+  "agents",
+  "reports",
+  "actions",
+  "translations",
+  "themes",
+  "datasets",
+  "apis",
+  "triggers",
+  "workflows"
+]).describe("Metadata category within the artifact");
+var ArtifactFileEntrySchema = zod.z.object({
+  /** Relative path within the artifact (e.g. "metadata/objects/account.object.json") */
+  path: zod.z.string().describe("Relative file path within the artifact"),
+  /** File size in bytes */
+  size: zod.z.number().int().nonnegative().describe("File size in bytes"),
+  /** Metadata category (if under metadata/) */
+  category: MetadataCategoryEnum.optional().describe("Metadata category this file belongs to")
+}).describe("A single file entry within the artifact");
+var ArtifactChecksumSchema = zod.z.object({
+  /** Hash algorithm used (default: SHA256) */
+  algorithm: zod.z.enum(["sha256", "sha384", "sha512"]).default("sha256").describe("Hash algorithm used for checksums"),
+  /** Map of relative file paths to their hash values */
+  files: zod.z.record(zod.z.string(), zod.z.string().regex(/^[a-f0-9]+$/)).describe("File path to hash value mapping")
+}).describe("Checksum manifest for artifact integrity verification");
+var ArtifactSignatureSchema = zod.z.object({
+  /** Signature algorithm */
+  algorithm: zod.z.enum(["RSA-SHA256", "RSA-SHA384", "RSA-SHA512", "ECDSA-SHA256"]).default("RSA-SHA256").describe("Signing algorithm used"),
+  /** Public key reference (URL or fingerprint) for verification */
+  publicKeyRef: zod.z.string().describe("Public key reference (URL or fingerprint) for signature verification"),
+  /** Base64-encoded signature value */
+  signature: zod.z.string().describe("Base64-encoded digital signature"),
+  /** Timestamp of when the artifact was signed */
+  signedAt: zod.z.string().datetime().optional().describe("ISO 8601 timestamp of when the artifact was signed"),
+  /** Signer identity (publisher ID or email) */
+  signedBy: zod.z.string().optional().describe("Identity of the signer (publisher ID or email)")
+}).describe("Digital signature for artifact authenticity verification");
+var PackageArtifactSchema = zod.z.object({
+  /** Artifact format version (for forward compatibility) */
+  formatVersion: zod.z.string().regex(/^\d+\.\d+$/).default("1.0").describe('Artifact format version (e.g. "1.0")'),
+  /** Package ID from the manifest */
+  packageId: zod.z.string().describe("Package identifier from manifest"),
+  /** Package version from the manifest */
+  version: zod.z.string().describe("Package version from manifest"),
+  /** Artifact format */
+  format: zod.z.enum(["tgz", "zip"]).default("tgz").describe("Archive format of the artifact"),
+  /** Total artifact size in bytes */
+  size: zod.z.number().int().positive().optional().describe("Total artifact file size in bytes"),
+  /** Build timestamp */
+  builtAt: zod.z.string().datetime().describe("ISO 8601 timestamp of when the artifact was built"),
+  /** Build tool and version that produced this artifact */
+  builtWith: zod.z.string().optional().describe('Build tool identifier (e.g. "os-cli@3.2.0")'),
+  /** File listing within the artifact */
+  files: zod.z.array(ArtifactFileEntrySchema).optional().describe("List of files contained in the artifact"),
+  /** Metadata categories present in the artifact */
+  metadataCategories: zod.z.array(MetadataCategoryEnum).optional().describe("Metadata categories included in this artifact"),
+  /** Integrity checksums for all files */
+  checksums: ArtifactChecksumSchema.optional().describe("SHA256 checksums for artifact integrity verification"),
+  /** Digital signature for authenticity */
+  signature: ArtifactSignatureSchema.optional().describe("Digital signature for artifact authenticity verification")
+}).describe("Package artifact structure and metadata");
+var PublisherVerificationSchema = zod.z.enum([
+  "unverified",
+  // Not yet verified
+  "pending",
+  // Verification in progress
+  "verified",
+  // Identity verified by platform
+  "trusted",
+  // Trusted publisher (track record of quality)
+  "partner"
+  // Official platform partner
+]).describe("Publisher verification status");
+zod.z.object({
+  /** Publisher unique identifier */
+  id: zod.z.string().describe("Publisher ID"),
+  /** Display name */
+  name: zod.z.string().describe("Publisher display name"),
+  /** Publisher type */
+  type: zod.z.enum(["individual", "organization"]).describe("Publisher type"),
+  /** Verification status */
+  verification: PublisherVerificationSchema.default("unverified").describe("Publisher verification status"),
+  /** Contact email */
+  email: zod.z.string().email().optional().describe("Contact email"),
+  /** Website URL */
+  website: zod.z.string().url().optional().describe("Publisher website"),
+  /** Organization logo URL */
+  logoUrl: zod.z.string().url().optional().describe("Publisher logo URL"),
+  /** Short description/bio */
+  description: zod.z.string().optional().describe("Publisher description"),
+  /** Registration date */
+  registeredAt: zod.z.string().datetime().optional().describe("Publisher registration timestamp")
+}).describe("Developer or organization that publishes packages");
+var ArtifactReferenceSchema = zod.z.object({
+  /** Artifact download URL */
+  url: zod.z.string().url().describe("Artifact download URL"),
+  /** SHA256 integrity checksum */
+  sha256: zod.z.string().regex(/^[a-f0-9]{64}$/).describe("SHA256 checksum"),
+  /** File size in bytes */
+  size: zod.z.number().int().positive().describe("Artifact size in bytes"),
+  /** Artifact format */
+  format: zod.z.enum(["tgz", "zip"]).default("tgz").describe("Artifact format"),
+  /** Upload timestamp */
+  uploadedAt: zod.z.string().datetime().describe("Upload timestamp")
+}).describe("Reference to a downloadable package artifact");
+zod.z.object({
+  /** Pre-signed or direct download URL */
+  downloadUrl: zod.z.string().url().describe("Artifact download URL (may be pre-signed)"),
+  /** SHA256 checksum for download verification */
+  sha256: zod.z.string().regex(/^[a-f0-9]{64}$/).describe("SHA256 checksum for verification"),
+  /** File size in bytes */
+  size: zod.z.number().int().positive().describe("Artifact size in bytes"),
+  /** Artifact format */
+  format: zod.z.enum(["tgz", "zip"]).describe("Artifact format"),
+  /** URL expiration time (for pre-signed URLs) */
+  expiresAt: zod.z.string().datetime().optional().describe("URL expiration timestamp for pre-signed URLs")
+}).describe("Artifact download response with integrity metadata");
+var MarketplaceCategorySchema = zod.z.enum([
+  "crm",
+  // Customer Relationship Management
+  "erp",
+  // Enterprise Resource Planning
+  "hr",
+  // Human Resources
+  "finance",
+  // Finance & Accounting
+  "project",
+  // Project Management
+  "collaboration",
+  // Collaboration & Communication
+  "analytics",
+  // Analytics & Reporting
+  "integration",
+  // Integrations & Connectors
+  "automation",
+  // Automation & Workflows
+  "ai",
+  // AI & Machine Learning
+  "security",
+  // Security & Compliance
+  "developer-tools",
+  // Developer Tools
+  "ui-theme",
+  // UI Themes & Appearance
+  "storage",
+  // Storage & Drivers
+  "other"
+  // Other / Uncategorized
+]).describe("Marketplace package category");
+var ListingStatusSchema = zod.z.enum([
+  "draft",
+  // Not yet submitted
+  "submitted",
+  // Submitted for review
+  "in-review",
+  // Under review
+  "approved",
+  // Approved, ready to publish
+  "published",
+  // Live on marketplace
+  "rejected",
+  // Review rejected
+  "suspended",
+  // Suspended by platform (policy violation)
+  "deprecated",
+  // Deprecated by publisher
+  "unlisted"
+  // Available by direct link only
+]).describe("Marketplace listing status");
+var PricingModelSchema = zod.z.enum([
+  "free",
+  // Free to install
+  "freemium",
+  // Free with paid premium features
+  "paid",
+  // Requires purchase
+  "subscription",
+  // Recurring subscription
+  "usage-based",
+  // Pay per usage
+  "contact-sales"
+  // Enterprise pricing, contact for quote
+]).describe("Package pricing model");
+var MarketplaceListingSchema = zod.z.object({
+  /** Listing ID (matches package ID) */
+  id: zod.z.string().describe("Listing ID (matches package manifest ID)"),
+  /** Package ID (reverse domain notation) */
+  packageId: zod.z.string().describe("Package identifier"),
+  /** Publisher information */
+  publisherId: zod.z.string().describe("Publisher ID"),
+  /** Current listing status */
+  status: ListingStatusSchema.default("draft").describe("Publication state: draft, published, under-review, suspended, deprecated, or unlisted"),
+  /** Display name */
+  name: zod.z.string().describe("Display name"),
+  /** Tagline (short description for cards/search results) */
+  tagline: zod.z.string().max(120).optional().describe("Short tagline (max 120 chars)"),
+  /** Full description (supports Markdown) */
+  description: zod.z.string().optional().describe("Full description (Markdown)"),
+  /** Category */
+  category: MarketplaceCategorySchema.describe("Package category"),
+  /** Additional tags for search discovery */
+  tags: zod.z.array(zod.z.string()).optional().describe("Search tags"),
+  /** Icon/logo URL */
+  iconUrl: zod.z.string().url().optional().describe("Package icon URL"),
+  /** Screenshot URLs */
+  screenshots: zod.z.array(zod.z.object({
+    url: zod.z.string().url(),
+    caption: zod.z.string().optional()
+  })).optional().describe("Screenshots"),
+  /** Documentation URL */
+  documentationUrl: zod.z.string().url().optional().describe("Documentation URL"),
+  /** Support URL */
+  supportUrl: zod.z.string().url().optional().describe("Support URL"),
+  /** Source repository URL (if open source) */
+  repositoryUrl: zod.z.string().url().optional().describe("Source repository URL"),
+  /** Pricing model */
+  pricing: PricingModelSchema.default("free").describe("Pricing model"),
+  /** Price in cents (if paid) */
+  priceInCents: zod.z.number().int().min(0).optional().describe("Price in cents (e.g. 999 = $9.99)"),
+  /** Latest published version */
+  latestVersion: zod.z.string().describe("Latest published version"),
+  /** Minimum platform version required */
+  minPlatformVersion: zod.z.string().optional().describe("Minimum ObjectStack platform version"),
+  /** Available versions for installation */
+  versions: zod.z.array(zod.z.object({
+    version: zod.z.string().describe("Version string"),
+    releaseDate: zod.z.string().datetime().describe("Release date"),
+    releaseNotes: zod.z.string().optional().describe("Release notes"),
+    minPlatformVersion: zod.z.string().optional().describe("Minimum platform version"),
+    deprecated: zod.z.boolean().default(false).describe("Whether this version is deprecated"),
+    /** Artifact reference for this version */
+    artifact: ArtifactReferenceSchema.optional().describe("Downloadable artifact for this version")
+  })).optional().describe("Published versions"),
+  /** Aggregate statistics */
+  stats: zod.z.object({
+    totalInstalls: zod.z.number().int().min(0).default(0).describe("Total installs"),
+    activeInstalls: zod.z.number().int().min(0).default(0).describe("Active installs"),
+    averageRating: zod.z.number().min(0).max(5).optional().describe("Average user rating (0-5)"),
+    totalRatings: zod.z.number().int().min(0).default(0).describe("Total ratings count"),
+    totalReviews: zod.z.number().int().min(0).default(0).describe("Total reviews count")
+  }).optional().describe("Aggregate marketplace statistics"),
+  /** First published date */
+  publishedAt: zod.z.string().datetime().optional().describe("First published timestamp"),
+  /** Last updated date */
+  updatedAt: zod.z.string().datetime().optional().describe("Last updated timestamp")
+}).describe("Public-facing package listing on the marketplace");
+zod.z.object({
+  /** Submission ID */
+  id: zod.z.string().describe("Submission ID"),
+  /** Package ID */
+  packageId: zod.z.string().describe("Package identifier"),
+  /** Version being submitted */
+  version: zod.z.string().describe("Version being submitted"),
+  /** Publisher ID */
+  publisherId: zod.z.string().describe("Publisher submitting"),
+  /** Submission status */
+  status: zod.z.enum([
+    "pending",
+    // Awaiting review
+    "scanning",
+    // Automated scan in progress
+    "in-review",
+    // Under manual review
+    "changes-requested",
+    // Reviewer requests changes
+    "approved",
+    // Approved for publishing
+    "rejected"
+    // Rejected
+  ]).default("pending").describe("Review status"),
+  /**
+   * Package artifact URL or reference.
+   * Points to the built package bundle for review.
+   */
+  artifactUrl: zod.z.string().describe("Package artifact URL for review"),
+  /** Release notes for this version */
+  releaseNotes: zod.z.string().optional().describe("Release notes for this version"),
+  /** Whether this is the first submission (new listing) vs version update */
+  isNewListing: zod.z.boolean().default(false).describe("Whether this is a new listing submission"),
+  /** Automated scan results */
+  scanResults: zod.z.object({
+    /** Whether automated scan passed */
+    passed: zod.z.boolean(),
+    /** Security scan score (0-100) */
+    securityScore: zod.z.number().min(0).max(100).optional(),
+    /** Compatibility check passed */
+    compatibilityCheck: zod.z.boolean().optional(),
+    /** Issues found during scan */
+    issues: zod.z.array(zod.z.object({
+      severity: zod.z.enum(["critical", "high", "medium", "low", "info"]),
+      message: zod.z.string(),
+      file: zod.z.string().optional(),
+      line: zod.z.number().optional()
+    })).optional()
+  }).optional().describe("Automated scan results"),
+  /** Reviewer notes (from platform reviewer) */
+  reviewerNotes: zod.z.string().optional().describe("Notes from the platform reviewer"),
+  /** Submitted timestamp */
+  submittedAt: zod.z.string().datetime().optional().describe("Submission timestamp"),
+  /** Review completed timestamp */
+  reviewedAt: zod.z.string().datetime().optional().describe("Review completion timestamp")
+}).describe("Developer submission of a package version for review");
+zod.z.object({
+  /** Search query string */
+  query: zod.z.string().optional().describe("Full-text search query"),
+  /** Filter by category */
+  category: MarketplaceCategorySchema.optional().describe("Filter by category"),
+  /** Filter by tags */
+  tags: zod.z.array(zod.z.string()).optional().describe("Filter by tags"),
+  /** Filter by pricing model */
+  pricing: PricingModelSchema.optional().describe("Filter by pricing model"),
+  /** Filter by publisher verification level */
+  publisherVerification: PublisherVerificationSchema.optional().describe("Filter by publisher verification level"),
+  /** Sort by */
+  sortBy: zod.z.enum([
+    "relevance",
+    // Best match (default for search)
+    "popularity",
+    // Most installs
+    "rating",
+    // Highest rated
+    "newest",
+    // Most recently published
+    "updated",
+    // Most recently updated
+    "name"
+    // Alphabetical
+  ]).default("relevance").describe("Sort field"),
+  /** Sort direction */
+  sortDirection: zod.z.enum(["asc", "desc"]).default("desc").describe("Sort direction"),
+  /** Pagination: page number */
+  page: zod.z.number().int().min(1).default(1).describe("Page number"),
+  /** Pagination: items per page */
+  pageSize: zod.z.number().int().min(1).max(100).default(20).describe("Items per page"),
+  /** Filter by minimum platform version compatibility */
+  platformVersion: zod.z.string().optional().describe("Filter by platform version compatibility")
+}).describe("Marketplace search request");
+zod.z.object({
+  /** Search results */
+  items: zod.z.array(MarketplaceListingSchema).describe("Search result listings"),
+  /** Total count (for pagination) */
+  total: zod.z.number().int().min(0).describe("Total matching results"),
+  /** Current page */
+  page: zod.z.number().int().min(1).describe("Current page number"),
+  /** Items per page */
+  pageSize: zod.z.number().int().min(1).describe("Items per page"),
+  /** Facets for filtering */
+  facets: zod.z.object({
+    categories: zod.z.array(zod.z.object({
+      category: MarketplaceCategorySchema,
+      count: zod.z.number().int().min(0)
+    })).optional(),
+    pricing: zod.z.array(zod.z.object({
+      model: PricingModelSchema,
+      count: zod.z.number().int().min(0)
+    })).optional()
+  }).optional().describe("Aggregation facets for refining search")
+}).describe("Marketplace search response");
+zod.z.object({
+  /** Listing ID to install */
+  listingId: zod.z.string().describe("Marketplace listing ID"),
+  /** Specific version to install (defaults to latest) */
+  version: zod.z.string().optional().describe("Version to install"),
+  /** License key (for paid packages) */
+  licenseKey: zod.z.string().optional().describe("License key for paid packages"),
+  /** User-provided settings at install time */
+  settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("User-provided settings at install time"),
+  /** Whether to enable immediately after install */
+  enableOnInstall: zod.z.boolean().default(true).describe("Whether to enable immediately after install"),
+  /** Artifact reference (resolved from listing version, or provided directly) */
+  artifactRef: ArtifactReferenceSchema.optional().describe("Artifact reference for direct installation"),
+  /** Tenant ID */
+  tenantId: zod.z.string().optional().describe("Tenant identifier")
+}).describe("Install from marketplace request");
+zod.z.object({
+  /** Whether installation was successful */
+  success: zod.z.boolean().describe("Whether installation succeeded"),
+  /** Installed package ID */
+  packageId: zod.z.string().optional().describe("Installed package identifier"),
+  /** Installed version */
+  version: zod.z.string().optional().describe("Installed version"),
+  /** Human-readable message */
+  message: zod.z.string().optional().describe("Installation status message")
+}).describe("Install from marketplace response");
+
+// src/api/package-api.zod.ts
+var PackagePathParamsSchema = zod.z.object({
+  packageId: zod.z.string().describe("Package identifier")
+});
+var ListInstalledPackagesRequestSchema = zod.z.object({
+  /** Filter by package status */
+  status: zod.z.enum(["installed", "disabled", "installing", "upgrading", "uninstalling", "error"]).optional().describe("Filter by package status"),
+  /** Filter by enabled state */
+  enabled: zod.z.boolean().optional().describe("Filter by enabled state"),
+  /** Maximum number of packages to return */
+  limit: zod.z.number().int().min(1).max(100).default(50).describe("Maximum number of packages to return"),
+  /** Cursor for pagination */
+  cursor: zod.z.string().optional().describe("Cursor for pagination")
+}).describe("List installed packages request");
+var ListInstalledPackagesResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    packages: zod.z.array(InstalledPackageSchema).describe("Installed packages"),
+    total: zod.z.number().int().optional().describe("Total matching packages"),
+    nextCursor: zod.z.string().optional().describe("Cursor for the next page"),
+    hasMore: zod.z.boolean().describe("Whether more packages are available")
+  })
+}).describe("List installed packages response");
+var GetInstalledPackageRequestSchema = PackagePathParamsSchema;
+var GetInstalledPackageResponseSchema = BaseResponseSchema.extend({
+  data: InstalledPackageSchema.describe("Installed package details")
+}).describe("Get installed package response");
+var PackageInstallRequestSchema = zod.z.object({
+  /** Package manifest to install */
+  manifest: ManifestSchema.describe("Package manifest to install"),
+  /** User-provided settings at install time */
+  settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("User-provided settings at install time"),
+  /** Whether to enable immediately after install */
+  enableOnInstall: zod.z.boolean().default(true).describe("Whether to enable immediately after install"),
+  /** Current platform version for compatibility verification */
+  platformVersion: zod.z.string().optional().describe("Current platform version for compatibility verification"),
+  /** Artifact reference for the package (if installing from marketplace) */
+  artifactRef: ArtifactReferenceSchema.optional().describe("Artifact reference for marketplace installation")
+}).describe("Install package request");
+var PackageInstallResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    package: InstalledPackageSchema.describe("Installed package details"),
+    dependencyResolution: DependencyResolutionResultSchema.optional().describe("Dependency resolution result"),
+    namespaceConflicts: zod.z.array(zod.z.object({
+      type: zod.z.literal("namespace_conflict").describe("Error type"),
+      requestedNamespace: zod.z.string().describe("Requested namespace"),
+      conflictingPackageId: zod.z.string().describe("Conflicting package ID"),
+      conflictingPackageName: zod.z.string().describe("Conflicting package name"),
+      suggestion: zod.z.string().optional().describe("Suggested alternative")
+    })).optional().describe("Namespace conflicts detected"),
+    message: zod.z.string().optional().describe("Installation status message")
+  })
+}).describe("Install package response");
+var PackageUpgradeRequestSchema = zod.z.object({
+  /** Package ID to upgrade */
+  packageId: zod.z.string().describe("Package ID to upgrade"),
+  /** Target version (defaults to latest) */
+  targetVersion: zod.z.string().optional().describe("Target version (defaults to latest)"),
+  /** New manifest for the target version */
+  manifest: ManifestSchema.optional().describe("New manifest for the target version"),
+  /** Whether to create a pre-upgrade snapshot */
+  createSnapshot: zod.z.boolean().default(true).describe("Whether to create a pre-upgrade backup snapshot"),
+  /** Merge strategy for handling customizations */
+  mergeStrategy: zod.z.enum(["keep-custom", "accept-incoming", "three-way-merge"]).default("three-way-merge").describe("How to handle customer customizations"),
+  /** Preview upgrade without making changes */
+  dryRun: zod.z.boolean().default(false).describe("Preview upgrade without making changes"),
+  /** Skip pre-upgrade compatibility checks */
+  skipValidation: zod.z.boolean().default(false).describe("Skip pre-upgrade compatibility checks")
+}).describe("Upgrade package request");
+var PackageUpgradeResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    success: zod.z.boolean().describe("Whether the upgrade succeeded"),
+    phase: zod.z.string().describe("Current upgrade phase"),
+    plan: UpgradePlanSchema.optional().describe("Upgrade plan that was executed"),
+    snapshotId: zod.z.string().optional().describe("Snapshot ID for rollback"),
+    conflicts: zod.z.array(zod.z.object({
+      path: zod.z.string().describe("Conflict path"),
+      baseValue: zod.z.unknown().describe("Base value"),
+      incomingValue: zod.z.unknown().describe("Incoming value"),
+      customValue: zod.z.unknown().describe("Custom value")
+    })).optional().describe("Unresolved merge conflicts"),
+    errorMessage: zod.z.string().optional().describe("Error message if failed"),
+    message: zod.z.string().optional().describe("Human-readable status message")
+  })
+}).describe("Upgrade package response");
+var ResolveDependenciesRequestSchema = zod.z.object({
+  /** Package manifest whose dependencies to resolve */
+  manifest: ManifestSchema.describe("Package manifest to resolve dependencies for"),
+  /** Current platform version for compatibility checking */
+  platformVersion: zod.z.string().optional().describe("Current platform version for compatibility filtering")
+}).describe("Resolve dependencies request");
+var ResolveDependenciesResponseSchema = BaseResponseSchema.extend({
+  data: DependencyResolutionResultSchema.describe("Dependency resolution result with topological sort")
+}).describe("Resolve dependencies response");
+var UploadArtifactRequestSchema = zod.z.object({
+  /** Artifact metadata */
+  artifact: PackageArtifactSchema.describe("Package artifact metadata"),
+  /** SHA256 checksum of the uploaded file (for verification) */
+  sha256: zod.z.string().regex(/^[a-f0-9]{64}$/).optional().describe("SHA256 checksum of the uploaded file"),
+  /** Publisher authentication token */
+  token: zod.z.string().optional().describe("Publisher authentication token"),
+  /** Release notes for this version */
+  releaseNotes: zod.z.string().optional().describe("Release notes for this version")
+}).describe("Upload artifact request");
+var UploadArtifactResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    /** Whether the upload succeeded */
+    success: zod.z.boolean().describe("Whether the upload succeeded"),
+    /** Artifact reference for the uploaded package */
+    artifactRef: ArtifactReferenceSchema.optional().describe("Artifact reference in the registry"),
+    /** Submission ID for review tracking */
+    submissionId: zod.z.string().optional().describe("Marketplace submission ID for review tracking"),
+    /** Message */
+    message: zod.z.string().optional().describe("Upload status message")
+  })
+}).describe("Upload artifact response");
+var PackageRollbackRequestSchema = PackagePathParamsSchema.extend({
+  /** Snapshot ID to restore from */
+  snapshotId: zod.z.string().describe("Snapshot ID to restore from"),
+  /** Whether to also rollback customizations */
+  rollbackCustomizations: zod.z.boolean().default(true).describe("Whether to restore pre-upgrade customizations")
+}).describe("Rollback package request");
+var PackageRollbackResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    success: zod.z.boolean().describe("Whether the rollback succeeded"),
+    restoredVersion: zod.z.string().optional().describe("Restored version"),
+    message: zod.z.string().optional().describe("Rollback status message")
+  })
+}).describe("Rollback package response");
+var UninstallPackageApiRequestSchema = PackagePathParamsSchema;
+var UninstallPackageApiResponseSchema = BaseResponseSchema.extend({
+  data: zod.z.object({
+    packageId: zod.z.string().describe("Uninstalled package ID"),
+    success: zod.z.boolean().describe("Whether uninstall succeeded"),
+    message: zod.z.string().optional().describe("Uninstall status message")
+  })
+}).describe("Uninstall package response");
+var PackageApiErrorCode = zod.z.enum([
+  "package_not_found",
+  "package_already_installed",
+  "version_not_found",
+  "dependency_conflict",
+  "namespace_conflict",
+  "platform_incompatible",
+  "artifact_invalid",
+  "checksum_mismatch",
+  "signature_invalid",
+  "upgrade_failed",
+  "rollback_failed",
+  "snapshot_not_found",
+  "upload_failed"
+]);
+var PackageApiContracts = {
+  listPackages: {
+    method: "GET",
+    path: "/api/v1/packages",
+    input: ListInstalledPackagesRequestSchema,
+    output: ListInstalledPackagesResponseSchema
+  },
+  getPackage: {
+    method: "GET",
+    path: "/api/v1/packages/:packageId",
+    input: GetInstalledPackageRequestSchema,
+    output: GetInstalledPackageResponseSchema
+  },
+  installPackage: {
+    method: "POST",
+    path: "/api/v1/packages/install",
+    input: PackageInstallRequestSchema,
+    output: PackageInstallResponseSchema
+  },
+  upgradePackage: {
+    method: "POST",
+    path: "/api/v1/packages/upgrade",
+    input: PackageUpgradeRequestSchema,
+    output: PackageUpgradeResponseSchema
+  },
+  resolveDependencies: {
+    method: "POST",
+    path: "/api/v1/packages/resolve-dependencies",
+    input: ResolveDependenciesRequestSchema,
+    output: ResolveDependenciesResponseSchema
+  },
+  uploadArtifact: {
+    method: "POST",
+    path: "/api/v1/packages/upload",
+    input: UploadArtifactRequestSchema,
+    output: UploadArtifactResponseSchema
+  },
+  rollbackPackage: {
+    method: "POST",
+    path: "/api/v1/packages/:packageId/rollback",
+    input: PackageRollbackRequestSchema,
+    output: PackageRollbackResponseSchema
+  },
+  uninstallPackage: {
+    method: "DELETE",
+    path: "/api/v1/packages/:packageId",
+    input: UninstallPackageApiRequestSchema,
+    output: UninstallPackageApiResponseSchema
+  }
+};
 
 exports.AckMessageSchema = AckMessageSchema;
 exports.AddReactionRequestSchema = AddReactionRequestSchema;
@@ -10931,6 +12822,10 @@ exports.AuthEndpointAliases = AuthEndpointAliases;
 exports.AuthEndpointPaths = AuthEndpointPaths;
 exports.AuthEndpointSchema = AuthEndpointSchema;
 exports.AuthProvider = AuthProvider;
+exports.AutomationApiContracts = AutomationApiContracts;
+exports.AutomationApiErrorCode = AutomationApiErrorCode;
+exports.AutomationFlowPathParamsSchema = AutomationFlowPathParamsSchema;
+exports.AutomationRunPathParamsSchema = AutomationRunPathParamsSchema;
 exports.AutomationTriggerRequestSchema = AutomationTriggerRequestSchema;
 exports.AutomationTriggerResponseSchema = AutomationTriggerResponseSchema;
 exports.BasePresenceSchema = BasePresenceSchema;
@@ -10955,16 +12850,23 @@ exports.CacheInvalidationRequestSchema = CacheInvalidationRequestSchema;
 exports.CacheInvalidationResponseSchema = CacheInvalidationResponseSchema;
 exports.CacheInvalidationTarget = CacheInvalidationTarget;
 exports.CallbackSchema = CallbackSchema;
+exports.ChangelogEntrySchema = ChangelogEntrySchema;
 exports.CheckPermissionRequestSchema = CheckPermissionRequestSchema;
 exports.CheckPermissionResponseSchema = CheckPermissionResponseSchema;
 exports.CodeGenerationTemplateSchema = CodeGenerationTemplateSchema;
+exports.CompleteChunkedUploadRequestSchema = CompleteChunkedUploadRequestSchema;
+exports.CompleteChunkedUploadResponseSchema = CompleteChunkedUploadResponseSchema;
 exports.CompleteUploadRequestSchema = CompleteUploadRequestSchema;
 exports.ConceptListResponseSchema = ConceptListResponseSchema;
 exports.ConflictResolutionStrategy = ConflictResolutionStrategy;
 exports.CreateDataRequestSchema = CreateDataRequestSchema;
 exports.CreateDataResponseSchema = CreateDataResponseSchema;
+exports.CreateExportJobRequestSchema = CreateExportJobRequestSchema;
+exports.CreateExportJobResponseSchema = CreateExportJobResponseSchema;
 exports.CreateFeedItemRequestSchema = CreateFeedItemRequestSchema;
 exports.CreateFeedItemResponseSchema = CreateFeedItemResponseSchema;
+exports.CreateFlowRequestSchema = CreateFlowRequestSchema;
+exports.CreateFlowResponseSchema = CreateFlowResponseSchema;
 exports.CreateManyDataRequestSchema = CreateManyDataRequestSchema;
 exports.CreateManyDataResponseSchema = CreateManyDataResponseSchema;
 exports.CreateRequestSchema = CreateRequestSchema;
@@ -10991,10 +12893,13 @@ exports.DEFAULT_VERSIONING_CONFIG = DEFAULT_VERSIONING_CONFIG;
 exports.DEFAULT_VIEW_ROUTES = DEFAULT_VIEW_ROUTES;
 exports.DEFAULT_WORKFLOW_ROUTES = DEFAULT_WORKFLOW_ROUTES;
 exports.DataLoaderConfigSchema = DataLoaderConfigSchema;
+exports.DeduplicationStrategy = DeduplicationStrategy;
 exports.DeleteDataRequestSchema = DeleteDataRequestSchema;
 exports.DeleteDataResponseSchema = DeleteDataResponseSchema;
 exports.DeleteFeedItemRequestSchema = DeleteFeedItemRequestSchema;
 exports.DeleteFeedItemResponseSchema = DeleteFeedItemResponseSchema;
+exports.DeleteFlowRequestSchema = DeleteFlowRequestSchema;
+exports.DeleteFlowResponseSchema = DeleteFlowResponseSchema;
 exports.DeleteManyDataRequestSchema = DeleteManyDataRequestSchema;
 exports.DeleteManyDataResponseSchema = DeleteManyDataResponseSchema;
 exports.DeleteManyRequestSchema = DeleteManyRequestSchema;
@@ -11026,6 +12931,12 @@ exports.EventFilterSchema = EventFilterSchema;
 exports.EventMessageSchema = EventMessageSchema;
 exports.EventPatternSchema = EventPatternSchema;
 exports.EventSubscriptionSchema = EventSubscriptionSchema;
+exports.ExportApiContracts = ExportApiContracts;
+exports.ExportFormat = ExportFormat;
+exports.ExportImportTemplateSchema = ExportImportTemplateSchema;
+exports.ExportJobProgressSchema = ExportJobProgressSchema;
+exports.ExportJobStatus = ExportJobStatus;
+exports.ExportJobSummarySchema = ExportJobSummarySchema;
 exports.ExportRequestSchema = ExportRequestSchema;
 exports.FederationEntityKeySchema = FederationEntityKeySchema;
 exports.FederationEntitySchema = FederationEntitySchema;
@@ -11040,23 +12951,34 @@ exports.FeedListFilterType = FeedListFilterType;
 exports.FeedPathParamsSchema = FeedPathParamsSchema;
 exports.FeedUnsubscribeRequestSchema = FeedUnsubscribeRequestSchema;
 exports.FieldErrorSchema = FieldErrorSchema;
+exports.FieldMappingEntrySchema = FieldMappingEntrySchema;
+exports.FileTypeValidationSchema = FileTypeValidationSchema;
 exports.FileUploadResponseSchema = FileUploadResponseSchema;
 exports.FilterOperator = FilterOperator;
 exports.FindDataRequestSchema = FindDataRequestSchema;
 exports.FindDataResponseSchema = FindDataResponseSchema;
+exports.FlowSummarySchema = FlowSummarySchema;
 exports.GeneratedApiDocumentationSchema = GeneratedApiDocumentationSchema;
 exports.GeneratedEndpointSchema = GeneratedEndpointSchema;
 exports.GetAnalyticsMetaRequestSchema = GetAnalyticsMetaRequestSchema;
+exports.GetChangelogRequestSchema = GetChangelogRequestSchema;
+exports.GetChangelogResponseSchema = GetChangelogResponseSchema;
 exports.GetDataRequestSchema = GetDataRequestSchema;
 exports.GetDataResponseSchema = GetDataResponseSchema;
 exports.GetDiscoveryRequestSchema = GetDiscoveryRequestSchema;
 exports.GetDiscoveryResponseSchema = GetDiscoveryResponseSchema;
 exports.GetEffectivePermissionsRequestSchema = GetEffectivePermissionsRequestSchema;
 exports.GetEffectivePermissionsResponseSchema = GetEffectivePermissionsResponseSchema;
+exports.GetExportJobDownloadRequestSchema = GetExportJobDownloadRequestSchema;
+exports.GetExportJobDownloadResponseSchema = GetExportJobDownloadResponseSchema;
 exports.GetFeedRequestSchema = GetFeedRequestSchema;
 exports.GetFeedResponseSchema = GetFeedResponseSchema;
 exports.GetFieldLabelsRequestSchema = GetFieldLabelsRequestSchema;
 exports.GetFieldLabelsResponseSchema = GetFieldLabelsResponseSchema;
+exports.GetFlowRequestSchema = GetFlowRequestSchema;
+exports.GetFlowResponseSchema = GetFlowResponseSchema;
+exports.GetInstalledPackageRequestSchema = GetInstalledPackageRequestSchema;
+exports.GetInstalledPackageResponseSchema = GetInstalledPackageResponseSchema;
 exports.GetLocalesRequestSchema = GetLocalesRequestSchema;
 exports.GetLocalesResponseSchema = GetLocalesResponseSchema;
 exports.GetMetaItemCachedRequestSchema = GetMetaItemCachedRequestSchema;
@@ -11076,6 +12998,8 @@ exports.GetPackageResponseSchema = GetPackageResponseSchema;
 exports.GetPresenceRequestSchema = GetPresenceRequestSchema;
 exports.GetPresenceResponseSchema = GetPresenceResponseSchema;
 exports.GetPresignedUrlRequestSchema = GetPresignedUrlRequestSchema;
+exports.GetRunRequestSchema = GetRunRequestSchema;
+exports.GetRunResponseSchema = GetRunResponseSchema;
 exports.GetTranslationsRequestSchema = GetTranslationsRequestSchema;
 exports.GetTranslationsResponseSchema = GetTranslationsResponseSchema;
 exports.GetUiViewRequestSchema = GetUiViewRequestSchema;
@@ -11105,13 +13029,26 @@ exports.GraphQLTypeConfigSchema = GraphQLTypeConfigSchema;
 exports.HttpMethod = HttpMethod;
 exports.HttpStatusCode = HttpStatusCode;
 exports.IdRequestSchema = IdRequestSchema;
+exports.ImportValidationConfigSchema = ImportValidationConfigSchema;
+exports.ImportValidationMode = ImportValidationMode;
+exports.ImportValidationResultSchema = ImportValidationResultSchema;
+exports.InitiateChunkedUploadRequestSchema = InitiateChunkedUploadRequestSchema;
+exports.InitiateChunkedUploadResponseSchema = InitiateChunkedUploadResponseSchema;
 exports.InstallPackageRequestSchema = InstallPackageRequestSchema;
 exports.InstallPackageResponseSchema = InstallPackageResponseSchema;
+exports.ListExportJobsRequestSchema = ListExportJobsRequestSchema;
+exports.ListExportJobsResponseSchema = ListExportJobsResponseSchema;
+exports.ListFlowsRequestSchema = ListFlowsRequestSchema;
+exports.ListFlowsResponseSchema = ListFlowsResponseSchema;
+exports.ListInstalledPackagesRequestSchema = ListInstalledPackagesRequestSchema;
+exports.ListInstalledPackagesResponseSchema = ListInstalledPackagesResponseSchema;
 exports.ListNotificationsRequestSchema = ListNotificationsRequestSchema;
 exports.ListNotificationsResponseSchema = ListNotificationsResponseSchema;
 exports.ListPackagesRequestSchema = ListPackagesRequestSchema;
 exports.ListPackagesResponseSchema = ListPackagesResponseSchema;
 exports.ListRecordResponseSchema = ListRecordResponseSchema;
+exports.ListRunsRequestSchema = ListRunsRequestSchema;
+exports.ListRunsResponseSchema = ListRunsResponseSchema;
 exports.ListViewsRequestSchema = ListViewsRequestSchema;
 exports.ListViewsResponseSchema = ListViewsResponseSchema;
 exports.LoginRequestSchema = LoginRequestSchema;
@@ -11170,6 +13107,17 @@ exports.OpenApiServerSchema = OpenApiServerSchema;
 exports.OpenApiSpec = OpenApiSpec;
 exports.OpenApiSpecSchema = OpenApiSpecSchema;
 exports.OperatorMappingSchema = OperatorMappingSchema;
+exports.PackageApiContracts = PackageApiContracts;
+exports.PackageApiErrorCode = PackageApiErrorCode;
+exports.PackageInstallRequestSchema = PackageInstallRequestSchema;
+exports.PackageInstallResponseSchema = PackageInstallResponseSchema;
+exports.PackagePathParamsSchema = PackagePathParamsSchema;
+exports.PackageRollbackRequestSchema = PackageRollbackRequestSchema;
+exports.PackageRollbackResponseSchema = PackageRollbackResponseSchema;
+exports.PackageUpgradeRequestSchema = PackageUpgradeRequestSchema;
+exports.PackageUpgradeResponseSchema = PackageUpgradeResponseSchema;
+exports.PinFeedItemRequestSchema = PinFeedItemRequestSchema;
+exports.PinFeedItemResponseSchema = PinFeedItemResponseSchema;
 exports.PingMessageSchema = PingMessageSchema;
 exports.PongMessageSchema = PongMessageSchema;
 exports.PresenceMessageSchema = PresenceMessageSchema;
@@ -11201,6 +13149,8 @@ exports.RegisterRequestSchema = RegisterRequestSchema;
 exports.RemoveReactionRequestSchema = RemoveReactionRequestSchema;
 exports.RemoveReactionResponseSchema = RemoveReactionResponseSchema;
 exports.RequestValidationConfigSchema = RequestValidationConfigSchema;
+exports.ResolveDependenciesRequestSchema = ResolveDependenciesRequestSchema;
+exports.ResolveDependenciesResponseSchema = ResolveDependenciesResponseSchema;
 exports.ResponseEnvelopeConfigSchema = ResponseEnvelopeConfigSchema;
 exports.RestApiConfig = RestApiConfig;
 exports.RestApiConfigSchema = RestApiConfigSchema;
@@ -11220,7 +13170,12 @@ exports.RouteGenerationConfigSchema = RouteGenerationConfigSchema;
 exports.RouterConfigSchema = RouterConfigSchema;
 exports.SaveMetaItemRequestSchema = SaveMetaItemRequestSchema;
 exports.SaveMetaItemResponseSchema = SaveMetaItemResponseSchema;
+exports.ScheduleExportRequestSchema = ScheduleExportRequestSchema;
+exports.ScheduleExportResponseSchema = ScheduleExportResponseSchema;
+exports.ScheduledExportSchema = ScheduledExportSchema;
 exports.SchemaDefinition = SchemaDefinition;
+exports.SearchFeedRequestSchema = SearchFeedRequestSchema;
+exports.SearchFeedResponseSchema = SearchFeedResponseSchema;
 exports.ServiceInfoSchema = ServiceInfoSchema;
 exports.SessionResponseSchema = SessionResponseSchema;
 exports.SessionSchema = SessionSchema;
@@ -11232,17 +13187,30 @@ exports.SimplePresenceStateSchema = SimplePresenceStateSchema;
 exports.SingleRecordResponseSchema = SingleRecordResponseSchema;
 exports.StandardApiContracts = StandardApiContracts;
 exports.StandardErrorCode = StandardErrorCode;
+exports.StarFeedItemRequestSchema = StarFeedItemRequestSchema;
+exports.StarFeedItemResponseSchema = StarFeedItemResponseSchema;
+exports.StorageApiContracts = StorageApiContracts;
 exports.SubgraphConfigSchema = SubgraphConfigSchema;
 exports.SubscribeMessageSchema = SubscribeMessageSchema;
 exports.SubscribeRequestSchema = SubscribeRequestSchema;
 exports.SubscribeResponseSchema = SubscribeResponseSchema;
 exports.SubscriptionEventSchema = SubscriptionEventSchema;
 exports.SubscriptionSchema = SubscriptionSchema;
+exports.ToggleFlowRequestSchema = ToggleFlowRequestSchema;
+exports.ToggleFlowResponseSchema = ToggleFlowResponseSchema;
 exports.TransportProtocol = TransportProtocol;
+exports.TriggerFlowRequestSchema = TriggerFlowRequestSchema;
+exports.TriggerFlowResponseSchema = TriggerFlowResponseSchema;
+exports.UninstallPackageApiRequestSchema = UninstallPackageApiRequestSchema;
+exports.UninstallPackageApiResponseSchema = UninstallPackageApiResponseSchema;
 exports.UninstallPackageRequestSchema = UninstallPackageRequestSchema;
 exports.UninstallPackageResponseSchema = UninstallPackageResponseSchema;
+exports.UnpinFeedItemRequestSchema = UnpinFeedItemRequestSchema;
+exports.UnpinFeedItemResponseSchema = UnpinFeedItemResponseSchema;
 exports.UnregisterDeviceRequestSchema = UnregisterDeviceRequestSchema;
 exports.UnregisterDeviceResponseSchema = UnregisterDeviceResponseSchema;
+exports.UnstarFeedItemRequestSchema = UnstarFeedItemRequestSchema;
+exports.UnstarFeedItemResponseSchema = UnstarFeedItemResponseSchema;
 exports.UnsubscribeMessageSchema = UnsubscribeMessageSchema;
 exports.UnsubscribeRequestSchema = UnsubscribeRequestSchema;
 exports.UnsubscribeResponseSchema = UnsubscribeResponseSchema;
@@ -11250,6 +13218,8 @@ exports.UpdateDataRequestSchema = UpdateDataRequestSchema;
 exports.UpdateDataResponseSchema = UpdateDataResponseSchema;
 exports.UpdateFeedItemRequestSchema = UpdateFeedItemRequestSchema;
 exports.UpdateFeedItemResponseSchema = UpdateFeedItemResponseSchema;
+exports.UpdateFlowRequestSchema = UpdateFlowRequestSchema;
+exports.UpdateFlowResponseSchema = UpdateFlowResponseSchema;
 exports.UpdateManyDataRequestSchema = UpdateManyDataRequestSchema;
 exports.UpdateManyDataResponseSchema = UpdateManyDataResponseSchema;
 exports.UpdateManyRequestSchema = UpdateManyRequestSchema;
@@ -11258,6 +13228,11 @@ exports.UpdateNotificationPreferencesResponseSchema = UpdateNotificationPreferen
 exports.UpdateRequestSchema = UpdateRequestSchema;
 exports.UpdateViewRequestSchema = UpdateViewRequestSchema;
 exports.UpdateViewResponseSchema = UpdateViewResponseSchema;
+exports.UploadArtifactRequestSchema = UploadArtifactRequestSchema;
+exports.UploadArtifactResponseSchema = UploadArtifactResponseSchema;
+exports.UploadChunkRequestSchema = UploadChunkRequestSchema;
+exports.UploadChunkResponseSchema = UploadChunkResponseSchema;
+exports.UploadProgressSchema = UploadProgressSchema;
 exports.UserProfileResponseSchema = UserProfileResponseSchema;
 exports.ValidationMode = ValidationMode;
 exports.VersionDefinitionSchema = VersionDefinitionSchema;
@@ -11273,6 +13248,7 @@ exports.WebSocketPresenceStatus = WebSocketPresenceStatus;
 exports.WebSocketServerConfigSchema = WebSocketServerConfigSchema;
 exports.WebhookConfigSchema = WebhookConfigSchema;
 exports.WebhookEventSchema = WebhookEventSchema;
+exports.WellKnownCapabilitiesSchema = WellKnownCapabilitiesSchema;
 exports.WorkflowApproveRequestSchema = WorkflowApproveRequestSchema;
 exports.WorkflowApproveResponseSchema = WorkflowApproveResponseSchema;
 exports.WorkflowRejectRequestSchema = WorkflowRejectRequestSchema;