@bubblelab/shared-schemas 0.1.45 → 0.1.46

package/dist/index.js

@@ -421,7 +421,9 @@ var SYSTEM_CREDENTIALS = /* @__PURE__ */ new Set([
   "CLOUDFLARE_R2_ACCOUNT_ID" /* CLOUDFLARE_R2_ACCOUNT_ID */,
   // Scraping credentials
   "APIFY_CRED" /* APIFY_CRED */,
-  "CRUSTDATA_API_KEY" /* CRUSTDATA_API_KEY */
+  "CRUSTDATA_API_KEY" /* CRUSTDATA_API_KEY */,
+  // Enrichment credentials
+  "FULLENRICH_API_KEY" /* FULLENRICH_API_KEY */
 ]);
 var OPTIONAL_CREDENTIALS = /* @__PURE__ */ new Set([
   "CUSTOM_AUTH_KEY" /* CUSTOM_AUTH_KEY */,
@@ -2837,124 +2839,291 @@ var webhookResponseSchema = z12.object({
 }).openapi("WebhookResponse");
 
 // src/subscription-status-schema.ts
+import { z as z14 } from "@hono/zod-openapi";
+
+// src/organization-schema.ts
 import { z as z13 } from "@hono/zod-openapi";
-var hackathonOfferSchema = z13.object({
-  isActive: z13.boolean().openapi({
+var orgRoleSchema = z13.enum(["owner", "admin", "member"]).openapi("OrgRole");
+var orgTypeSchema = z13.enum(["personal", "organization"]).openapi("OrgType");
+var organizationSchema = z13.object({
+  id: z13.number().openapi({
+    description: "Organization ID",
+    example: 123
+  }),
+  name: z13.string().openapi({
+    description: "Organization name",
+    example: "My Team"
+  }),
+  slug: z13.string().openapi({
+    description: "Organization slug for URLs",
+    example: "my-team"
+  }),
+  type: orgTypeSchema,
+  role: orgRoleSchema.openapi({
+    description: "Current user's role in this organization"
+  }),
+  memberCount: z13.number().openapi({
+    description: "Number of members in the organization",
+    example: 5
+  }),
+  createdAt: z13.string().openapi({
+    description: "ISO timestamp when organization was created",
+    example: "2024-01-01T00:00:00Z"
+  })
+}).openapi("Organization");
+var organizationDetailSchema = organizationSchema.extend({
+  workflowCount: z13.number().openapi({
+    description: "Number of workflows in the organization",
+    example: 10
+  }),
+  updatedAt: z13.string().openapi({
+    description: "ISO timestamp when organization was last updated",
+    example: "2024-01-02T00:00:00Z"
+  })
+}).openapi("OrganizationDetail");
+var organizationMemberSchema = z13.object({
+  userId: z13.string().openapi({
+    description: "User ID",
+    example: "user_123"
+  }),
+  email: z13.string().openapi({
+    description: "User email",
+    example: "user@example.com"
+  }),
+  name: z13.string().nullable().openapi({
+    description: "User display name",
+    example: "John Doe"
+  }),
+  avatarUrl: z13.string().optional().openapi({
+    description: "User avatar URL",
+    example: "https://example.com/avatar.png"
+  }),
+  role: orgRoleSchema,
+  joinedAt: z13.string().openapi({
+    description: "ISO timestamp when user joined the organization",
+    example: "2024-01-01T00:00:00Z"
+  })
+}).openapi("OrganizationMember");
+var createOrganizationSchema = z13.object({
+  name: z13.string().min(1).max(100).openapi({
+    description: "Organization name",
+    example: "My Team"
+  }),
+  slug: z13.string().min(3).max(50).regex(/^[a-z0-9-]+$/, "Slug must be lowercase alphanumeric with hyphens").openapi({
+    description: "Organization slug for URLs",
+    example: "my-team"
+  })
+}).openapi("CreateOrganizationRequest");
+var updateOrganizationSchema = z13.object({
+  name: z13.string().min(1).max(100).optional().openapi({
+    description: "Organization name",
+    example: "My Team"
+  }),
+  slug: z13.string().min(3).max(50).regex(/^[a-z0-9-]+$/, "Slug must be lowercase alphanumeric with hyphens").optional().openapi({
+    description: "Organization slug for URLs",
+    example: "my-team"
+  })
+}).openapi("UpdateOrganizationRequest");
+var addMemberSchema = z13.object({
+  email: z13.string().email().openapi({
+    description: "Email of the user to add",
+    example: "user@example.com"
+  }),
+  role: z13.enum(["admin", "member"]).openapi({
+    description: "Role to assign to the new member",
+    example: "member"
+  })
+}).openapi("AddMemberRequest");
+var updateMemberRoleSchema = z13.object({
+  role: z13.enum(["admin", "member"]).openapi({
+    description: "New role for the member",
+    example: "admin"
+  })
+}).openapi("UpdateMemberRoleRequest");
+var listOrganizationsResponseSchema = z13.object({
+  organizations: z13.array(organizationSchema)
+}).openapi("ListOrganizationsResponse");
+var updateOrganizationResponseSchema = z13.object({
+  id: z13.number(),
+  name: z13.string(),
+  slug: z13.string(),
+  updatedAt: z13.string()
+}).openapi("UpdateOrganizationResponse");
+var listMembersResponseSchema = z13.object({
+  members: z13.array(organizationMemberSchema)
+}).openapi("ListMembersResponse");
+var addMemberResponseSchema = z13.object({
+  userId: z13.string(),
+  role: orgRoleSchema,
+  joinedAt: z13.string()
+}).openapi("AddMemberResponse");
+var updateMemberRoleResponseSchema = z13.object({
+  userId: z13.string(),
+  role: orgRoleSchema
+}).openapi("UpdateMemberRoleResponse");
+var successResponseSchema = z13.object({
+  success: z13.boolean()
+}).openapi("SuccessResponse");
+
+// src/subscription-status-schema.ts
+var tokenUsageSchema = z14.object({
+  modelName: z14.string().optional().openapi({
+    description: "Model name",
+    example: "gpt-4"
+  }),
+  inputTokens: z14.number().openapi({
+    description: "Input tokens used this month",
+    example: 1500
+  }),
+  outputTokens: z14.number().openapi({
+    description: "Output tokens used this month",
+    example: 750
+  }),
+  totalTokens: z14.number().openapi({
+    description: "Total tokens used this month",
+    example: 2250
+  })
+}).openapi("TokenUsage");
+var usageSchema = z14.object({
+  executionCount: z14.number().openapi({
+    description: "Current monthly execution count",
+    example: 100
+  }),
+  tokenUsage: z14.array(tokenUsageSchema).openapi({
+    description: "Token usage breakdown by model for current month"
+  }),
+  serviceUsage: z14.array(ServiceUsageSchema).openapi({
+    description: "Service usage and cost breakdown for current month"
+  })
+}).openapi("Usage");
+var billingOrganizationSchema = z14.object({
+  id: z14.number().openapi({
+    description: "Organization ID",
+    example: 123
+  }),
+  name: z14.string().openapi({
+    description: "Organization name",
+    example: "My Team"
+  }),
+  slug: z14.string().openapi({
+    description: "Organization slug",
+    example: "my-team"
+  }),
+  role: orgRoleSchema.openapi({
+    description: "Current user's role in this organization"
+  }),
+  memberCount: z14.number().openapi({
+    description: "Number of members in the organization",
+    example: 5
+  })
+}).openapi("BillingOrganization");
+var hackathonOfferSchema = z14.object({
+  isActive: z14.boolean().openapi({
     description: "Whether a hackathon offer is currently active",
     example: true
   }),
-  expiresAt: z13.string().openapi({
+  expiresAt: z14.string().openapi({
     description: "ISO date when the hackathon offer expires",
     example: "2025-01-15T14:30:00.000Z"
   }),
-  redeemedAt: z13.string().openapi({
+  redeemedAt: z14.string().openapi({
     description: "ISO date when the code was redeemed",
     example: "2025-01-14T14:30:00.000Z"
   })
 }).openapi("HackathonOffer");
-var specialOfferSchema = z13.object({
-  isActive: z13.boolean().openapi({
+var specialOfferSchema = z14.object({
+  isActive: z14.boolean().openapi({
     description: "Whether a special offer is currently active",
     example: true
   }),
-  plan: z13.string().openapi({
+  plan: z14.string().openapi({
     description: "The plan granted by the special offer",
     example: "unlimited"
   }),
-  expiresAt: z13.string().nullable().openapi({
+  expiresAt: z14.string().nullable().openapi({
     description: "ISO date when the special offer expires (null = never expires)",
     example: "2025-06-15T14:30:00.000Z"
   })
 }).openapi("SpecialOffer");
-var redeemCouponRequestSchema = z13.object({
-  code: z13.string().min(1).openapi({
+var redeemCouponRequestSchema = z14.object({
+  code: z14.string().min(1).openapi({
     description: "The coupon code to redeem",
     example: "HACKATHON2025"
   })
 }).openapi("RedeemCouponRequest");
-var redeemCouponResponseSchema = z13.object({
-  success: z13.boolean().openapi({
+var redeemCouponResponseSchema = z14.object({
+  success: z14.boolean().openapi({
     description: "Whether the redemption was successful",
     example: true
   }),
-  message: z13.string().openapi({
+  message: z14.string().openapi({
     description: "Human-readable message about the redemption result",
     example: "Coupon redeemed successfully! You now have Pro access."
   }),
-  expiresAt: z13.string().optional().openapi({
+  expiresAt: z14.string().optional().openapi({
     description: "When the offer expires (if successful)",
     example: "2025-01-15T14:30:00.000Z"
   })
 }).openapi("RedeemCouponResponse");
-var subscriptionStatusResponseSchema = z13.object({
-  userId: z13.string().openapi({
+var subscriptionStatusResponseSchema = z14.object({
+  userId: z14.string().openapi({
     description: "User ID from Clerk",
     example: "user_30Gbwrzto1VZvAHcGUm5NLQhpkp"
   }),
-  plan: z13.string().openapi({
+  plan: z14.string().openapi({
     description: "Current subscription plan",
     example: "pro_plus"
   }),
-  planDisplayName: z13.string().openapi({
+  planDisplayName: z14.string().openapi({
     description: "Human-readable plan name",
     example: "Pro Plus"
   }),
-  features: z13.array(z13.string()).openapi({
+  features: z14.array(z14.string()).openapi({
     description: "List of features available to the user",
     example: ["unlimited_usage", "priority_support"]
   }),
-  usage: z13.object({
-    executionCount: z13.number().openapi({
-      description: "Current monthly execution count",
+  // Organization context - which org the billing belongs to
+  organization: billingOrganizationSchema.optional().openapi({
+    description: "Organization that owns the billing (null for personal accounts without org)"
+  }),
+  // Organization-level usage (what billing is based on)
+  usage: z14.object({
+    executionCount: z14.number().openapi({
+      description: "Organization monthly execution count",
       example: 100
     }),
-    executionLimit: z13.number().openapi({
-      description: "Current monthly execution limit",
+    executionLimit: z14.number().openapi({
+      description: "Organization monthly execution limit",
       example: 42
     }),
-    creditLimit: z13.number().openapi({
-      description: "Monthly credit limit",
+    creditLimit: z14.number().openapi({
+      description: "Organization monthly credit limit",
       example: 100
     }),
-    activeFlowLimit: z13.number().openapi({
-      description: "Current monthly active flow limit",
+    activeFlowLimit: z14.number().openapi({
+      description: "Organization monthly active flow limit",
       example: 2
     }),
-    estimatedMonthlyCost: z13.number().openapi({
+    estimatedMonthlyCost: z14.number().openapi({
       description: "Projected monthly cost based on current usage trend",
       example: 14.19
     }),
-    resetDate: z13.string().openapi({
+    resetDate: z14.string().openapi({
       description: "ISO date when usage resets",
       example: "2025-02-01T00:00:00.000Z"
     }),
-    tokenUsage: z13.array(
-      z13.object({
-        modelName: z13.string().openapi({
-          description: "Model name",
-          example: "gpt-4"
-        }),
-        inputTokens: z13.number().openapi({
-          description: "Input tokens used this month",
-          example: 1500
-        }),
-        outputTokens: z13.number().openapi({
-          description: "Output tokens used this month",
-          example: 750
-        }),
-        totalTokens: z13.number().openapi({
-          description: "Total tokens used this month",
-          example: 2250
-        })
-      })
-    ).openapi({
+    tokenUsage: z14.array(tokenUsageSchema).openapi({
       description: "Token usage breakdown by model for current month"
     }),
-    serviceUsage: z13.array(ServiceUsageSchema).openapi({
+    serviceUsage: z14.array(ServiceUsageSchema).openapi({
       description: "Service usage and cost breakdown for current month"
     })
   }),
-  isActive: z13.boolean().openapi({
+  // User's personal contribution to the organization usage
+  personalUsage: usageSchema.optional().openapi({
+    description: "User's personal contribution to the organization's usage for current billing period"
+  }),
+  isActive: z14.boolean().openapi({
     description: "Whether the subscription is active",
     example: true
   }),
@@ -2967,11 +3136,11 @@ var subscriptionStatusResponseSchema = z13.object({
 }).openapi("SubscriptionStatusResponse");
 
 // src/milk-tea.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/ai-models.ts
-import { z as z14 } from "zod";
-var AvailableModels = z14.enum([
+import { z as z15 } from "zod";
+var AvailableModels = z15.enum([
   // OpenAI models
   "openai/gpt-5",
   "openai/gpt-5-mini",
@@ -2999,111 +3168,111 @@ var AvailableModels = z14.enum([
 ]);
 
 // src/agent-memory.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var TOOL_CALL_TO_DISCARD = ["get-bubble-details-tool"];
-var ConversationMessageSchema = z15.object({
-  role: z15.enum(["user", "assistant", "tool"]).describe("The role of the message sender"),
-  content: z15.string().describe("The message content"),
-  toolCallId: z15.string().optional().describe("Tool call ID for tool messages"),
-  name: z15.string().optional().describe("Tool name for tool messages")
+var ConversationMessageSchema = z16.object({
+  role: z16.enum(["user", "assistant", "tool"]).describe("The role of the message sender"),
+  content: z16.string().describe("The message content"),
+  toolCallId: z16.string().optional().describe("Tool call ID for tool messages"),
+  name: z16.string().optional().describe("Tool name for tool messages")
 });
 
 // src/milk-tea.ts
-var MilkTeaRequestSchema = z16.object({
-  userRequest: z16.string().min(1, "User request is required").describe("The user request or question about configuring the bubble"),
-  bubbleName: z16.string().min(1, "Bubble name is required").describe('The name of the bubble to configure (e.g., "email-tool")'),
-  bubbleSchema: z16.record(z16.unknown()).describe(
+var MilkTeaRequestSchema = z17.object({
+  userRequest: z17.string().min(1, "User request is required").describe("The user request or question about configuring the bubble"),
+  bubbleName: z17.string().min(1, "Bubble name is required").describe('The name of the bubble to configure (e.g., "email-tool")'),
+  bubbleSchema: z17.record(z17.unknown()).describe(
     "The full schema/interface definition of the bubble including parameters and types"
   ),
-  currentCode: z16.string().optional().describe("The current workflow code context for validation"),
-  availableCredentials: z16.array(z16.string()).default([]).describe("List of credential types available to the user"),
-  userName: z16.string().describe("Name of the user making the request"),
-  insertLocation: z16.string().optional().describe("Location in code where the snippet should be inserted"),
-  conversationHistory: z16.array(ConversationMessageSchema).optional().default([]).describe(
+  currentCode: z17.string().optional().describe("The current workflow code context for validation"),
+  availableCredentials: z17.array(z17.string()).default([]).describe("List of credential types available to the user"),
+  userName: z17.string().describe("Name of the user making the request"),
+  insertLocation: z17.string().optional().describe("Location in code where the snippet should be inserted"),
+  conversationHistory: z17.array(ConversationMessageSchema).optional().default([]).describe(
     "Previous conversation messages for multi-turn interactions (frontend manages state)"
   ),
   model: AvailableModels.default("google/gemini-2.5-pro").describe(
     "AI model to use for Milk Tea agent"
   )
 });
-var MilkTeaResponseSchema = z16.object({
-  type: z16.enum(["code", "question", "reject"]).describe(
+var MilkTeaResponseSchema = z17.object({
+  type: z17.enum(["code", "question", "reject"]).describe(
     "Type of response: code (generated snippet), question (needs clarification), reject (infeasible request)"
   ),
-  message: z16.string().describe(
+  message: z17.string().describe(
     "Human-readable message: explanation for code, question text, or rejection reason"
   ),
-  snippet: z16.string().optional().describe(
+  snippet: z17.string().optional().describe(
     'Generated TypeScript code snippet (only present when type is "code")'
   ),
-  success: z16.boolean().describe("Whether the operation completed successfully"),
-  error: z16.string().optional().describe("Error message if the operation failed")
+  success: z17.boolean().describe("Whether the operation completed successfully"),
+  error: z17.string().optional().describe("Error message if the operation failed")
 });
-var MilkTeaAgentOutputSchema = z16.object({
-  type: z16.enum(["code", "question", "reject"]),
-  message: z16.string(),
-  snippet: z16.string().optional()
+var MilkTeaAgentOutputSchema = z17.object({
+  type: z17.enum(["code", "question", "reject"]),
+  message: z17.string(),
+  snippet: z17.string().optional()
 });
 
 // src/pearl.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var PEARL_DEFAULT_MODEL = "openrouter/anthropic/claude-sonnet-4.5";
-var PearlRequestSchema = z17.object({
-  userRequest: z17.string().min(1, "User request is required").describe("The user request or question about building a workflow"),
-  currentCode: z17.string().optional().describe("The current workflow code for context and modification"),
-  userName: z17.string().describe("Name of the user making the request"),
-  availableVariables: z17.array(z17.any()).describe("List of available variables in the current code"),
-  conversationHistory: z17.array(ConversationMessageSchema).optional().default([]).describe(
+var PearlRequestSchema = z18.object({
+  userRequest: z18.string().min(1, "User request is required").describe("The user request or question about building a workflow"),
+  currentCode: z18.string().optional().describe("The current workflow code for context and modification"),
+  userName: z18.string().describe("Name of the user making the request"),
+  availableVariables: z18.array(z18.any()).describe("List of available variables in the current code"),
+  conversationHistory: z18.array(ConversationMessageSchema).optional().default([]).describe(
     "Previous conversation messages for multi-turn interactions (frontend manages state)"
   ),
   model: AvailableModels.default(PEARL_DEFAULT_MODEL).describe(
     "AI model to use for Pearl agent"
   ),
-  additionalContext: z17.string().optional().describe(
+  additionalContext: z18.string().optional().describe(
     "Additional context information like timezone, user preferences, etc."
   ),
-  uploadedFiles: z17.array(
-    z17.object({
-      name: z17.string().describe("File name"),
-      content: z17.string().describe(
+  uploadedFiles: z18.array(
+    z18.object({
+      name: z18.string().describe("File name"),
+      content: z18.string().describe(
         "File content: base64 for images, plain text for text files"
       ),
-      fileType: z17.enum(["image", "text"]).describe("Type of file: image (base64) or text (plain text)")
+      fileType: z18.enum(["image", "text"]).describe("Type of file: image (base64) or text (plain text)")
     })
   ).optional().default([]).describe(
     "Files uploaded by the user: images as base64, text files as plain text"
   )
 });
-var PearlResponseSchema = z17.object({
-  type: z17.enum(["code", "question", "answer", "reject"]).describe(
+var PearlResponseSchema = z18.object({
+  type: z18.enum(["code", "question", "answer", "reject"]).describe(
     "Type of response: code (generated workflow), question (needs clarification), answer (provides information/guidance), reject (infeasible request)"
   ),
-  message: z17.string().describe(
+  message: z18.string().describe(
     "Human-readable message: explanation for code, question text, or rejection reason"
   ),
-  snippet: z17.string().optional().describe(
+  snippet: z18.string().optional().describe(
     'Generated TypeScript code for complete workflow (only present when type is "code")'
   ),
-  bubbleParameters: z17.record(z17.number(), ParsedBubbleWithInfoSchema).optional().describe(
+  bubbleParameters: z18.record(z18.number(), ParsedBubbleWithInfoSchema).optional().describe(
     'Parsed bubble parameters from the generated workflow (only present when type is "code")'
   ),
-  inputSchema: z17.record(z17.unknown()).optional().describe(
+  inputSchema: z18.record(z18.unknown()).optional().describe(
     'Input schema for the generated workflow (only present when type is "code")'
   ),
-  requiredCredentials: z17.record(z17.string(), z17.array(z17.nativeEnum(CredentialType))).optional().describe(
+  requiredCredentials: z18.record(z18.string(), z18.array(z18.nativeEnum(CredentialType))).optional().describe(
     'Required credentials for the bubbles in the workflow (only present when type is "code")'
   ),
-  success: z17.boolean().describe("Whether the operation completed successfully"),
-  error: z17.string().optional().describe("Error message if the operation failed")
+  success: z18.boolean().describe("Whether the operation completed successfully"),
+  error: z18.string().optional().describe("Error message if the operation failed")
 });
-var PearlAgentOutputSchema = z17.object({
-  type: z17.enum(["code", "question", "answer", "reject", "text"]),
-  message: z17.string(),
-  snippet: z17.string().optional()
+var PearlAgentOutputSchema = z18.object({
+  type: z18.enum(["code", "question", "answer", "reject", "text"]),
+  message: z18.string(),
+  snippet: z18.string().optional()
 });
 
 // src/rice.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/bubbleflow-generation-prompts.ts
 var RECOMMENDED_MODELS = {
@@ -3119,34 +3288,34 @@ var RECOMMENDED_MODELS = {
 
 // src/rice.ts
 var RICE_DEFAULT_MODEL = RECOMMENDED_MODELS.FAST;
-var RiceIssueTypeSchema = z18.enum(["setup", "workflow", "input"]).nullable();
-var RiceEvaluationResultSchema = z18.object({
-  working: z18.boolean().describe(
+var RiceIssueTypeSchema = z19.enum(["setup", "workflow", "input"]).nullable();
+var RiceEvaluationResultSchema = z19.object({
+  working: z19.boolean().describe(
     "Whether the workflow is functioning correctly (true if no errors and expected behavior)"
   ),
   issueType: RiceIssueTypeSchema.describe(
     'Category of issue: "setup" (config/credentials), "workflow" (code logic), "input" (bad input data), or null if working'
   ),
-  summary: z18.string().describe(
+  summary: z19.string().describe(
     "Brief summary of the execution. If working: what happened and any external changes made. If not working: description of the issue."
   ),
-  rating: z18.number().int().min(1).max(10).describe(
+  rating: z19.number().int().min(1).max(10).describe(
     "Quality rating 1-10: 1-3=severe issues, 4-6=partial functionality, 7-8=working with minor issues, 9-10=excellent"
   )
 });
-var RiceRequestSchema = z18.object({
-  executionLogs: z18.array(z18.unknown()).describe("StreamingLogEvent[] from execution"),
-  workflowCode: z18.string().describe("The original workflow code that was executed"),
-  executionId: z18.number().describe("ID of the execution being evaluated"),
-  bubbleFlowId: z18.number().describe("ID of the BubbleFlow being evaluated"),
+var RiceRequestSchema = z19.object({
+  executionLogs: z19.array(z19.unknown()).describe("StreamingLogEvent[] from execution"),
+  workflowCode: z19.string().describe("The original workflow code that was executed"),
+  executionId: z19.number().describe("ID of the execution being evaluated"),
+  bubbleFlowId: z19.number().describe("ID of the BubbleFlow being evaluated"),
   model: AvailableModels.optional().default(RICE_DEFAULT_MODEL).describe("AI model to use for Rice evaluation")
 });
-var RiceResponseSchema = z18.object({
-  success: z18.boolean().describe("Whether the evaluation completed successfully"),
+var RiceResponseSchema = z19.object({
+  success: z19.boolean().describe("Whether the evaluation completed successfully"),
   evaluation: RiceEvaluationResultSchema.optional().describe(
     "Evaluation result (only present if success=true)"
   ),
-  error: z18.string().optional().describe("Error message if the evaluation failed")
+  error: z19.string().optional().describe("Error message if the evaluation failed")
 });
 
 // src/cron-utils.ts
@@ -4064,130 +4233,6 @@ function buildParameterObjectLiteral(parameters, options) {
   }
   return paramsString;
 }
-
-// src/organization-schema.ts
-import { z as z19 } from "@hono/zod-openapi";
-var orgRoleSchema = z19.enum(["owner", "admin", "member"]).openapi("OrgRole");
-var orgTypeSchema = z19.enum(["personal", "organization"]).openapi("OrgType");
-var organizationSchema = z19.object({
-  id: z19.number().openapi({
-    description: "Organization ID",
-    example: 123
-  }),
-  name: z19.string().openapi({
-    description: "Organization name",
-    example: "My Team"
-  }),
-  slug: z19.string().openapi({
-    description: "Organization slug for URLs",
-    example: "my-team"
-  }),
-  type: orgTypeSchema,
-  role: orgRoleSchema.openapi({
-    description: "Current user's role in this organization"
-  }),
-  memberCount: z19.number().openapi({
-    description: "Number of members in the organization",
-    example: 5
-  }),
-  createdAt: z19.string().openapi({
-    description: "ISO timestamp when organization was created",
-    example: "2024-01-01T00:00:00Z"
-  })
-}).openapi("Organization");
-var organizationDetailSchema = organizationSchema.extend({
-  workflowCount: z19.number().openapi({
-    description: "Number of workflows in the organization",
-    example: 10
-  }),
-  updatedAt: z19.string().openapi({
-    description: "ISO timestamp when organization was last updated",
-    example: "2024-01-02T00:00:00Z"
-  })
-}).openapi("OrganizationDetail");
-var organizationMemberSchema = z19.object({
-  userId: z19.string().openapi({
-    description: "User ID",
-    example: "user_123"
-  }),
-  email: z19.string().openapi({
-    description: "User email",
-    example: "user@example.com"
-  }),
-  name: z19.string().nullable().openapi({
-    description: "User display name",
-    example: "John Doe"
-  }),
-  avatarUrl: z19.string().optional().openapi({
-    description: "User avatar URL",
-    example: "https://example.com/avatar.png"
-  }),
-  role: orgRoleSchema,
-  joinedAt: z19.string().openapi({
-    description: "ISO timestamp when user joined the organization",
-    example: "2024-01-01T00:00:00Z"
-  })
-}).openapi("OrganizationMember");
-var createOrganizationSchema = z19.object({
-  name: z19.string().min(1).max(100).openapi({
-    description: "Organization name",
-    example: "My Team"
-  }),
-  slug: z19.string().min(3).max(50).regex(/^[a-z0-9-]+$/, "Slug must be lowercase alphanumeric with hyphens").openapi({
-    description: "Organization slug for URLs",
-    example: "my-team"
-  })
-}).openapi("CreateOrganizationRequest");
-var updateOrganizationSchema = z19.object({
-  name: z19.string().min(1).max(100).optional().openapi({
-    description: "Organization name",
-    example: "My Team"
-  }),
-  slug: z19.string().min(3).max(50).regex(/^[a-z0-9-]+$/, "Slug must be lowercase alphanumeric with hyphens").optional().openapi({
-    description: "Organization slug for URLs",
-    example: "my-team"
-  })
-}).openapi("UpdateOrganizationRequest");
-var addMemberSchema = z19.object({
-  email: z19.string().email().openapi({
-    description: "Email of the user to add",
-    example: "user@example.com"
-  }),
-  role: z19.enum(["admin", "member"]).openapi({
-    description: "Role to assign to the new member",
-    example: "member"
-  })
-}).openapi("AddMemberRequest");
-var updateMemberRoleSchema = z19.object({
-  role: z19.enum(["admin", "member"]).openapi({
-    description: "New role for the member",
-    example: "admin"
-  })
-}).openapi("UpdateMemberRoleRequest");
-var listOrganizationsResponseSchema = z19.object({
-  organizations: z19.array(organizationSchema)
-}).openapi("ListOrganizationsResponse");
-var updateOrganizationResponseSchema = z19.object({
-  id: z19.number(),
-  name: z19.string(),
-  slug: z19.string(),
-  updatedAt: z19.string()
-}).openapi("UpdateOrganizationResponse");
-var listMembersResponseSchema = z19.object({
-  members: z19.array(organizationMemberSchema)
-}).openapi("ListMembersResponse");
-var addMemberResponseSchema = z19.object({
-  userId: z19.string(),
-  role: orgRoleSchema,
-  joinedAt: z19.string()
-}).openapi("AddMemberResponse");
-var updateMemberRoleResponseSchema = z19.object({
-  userId: z19.string(),
-  role: orgRoleSchema
-}).openapi("UpdateMemberRoleResponse");
-var successResponseSchema = z19.object({
-  success: z19.boolean()
-}).openapi("SuccessResponse");
 export {
   AssistantMessageSchema,
   AvailableModels,
@@ -4272,6 +4317,7 @@ export {
   activateBubbleFlowResponseSchema,
   addMemberResponseSchema,
   addMemberSchema,
+  billingOrganizationSchema,
   browserbaseSessionCompleteRequestSchema,
   browserbaseSessionCompleteResponseSchema,
   browserbaseSessionCreateRequestSchema,
@@ -4356,6 +4402,7 @@ export {
   subscriptionStatusResponseSchema,
   successMessageResponseSchema,
   successResponseSchema,
+  tokenUsageSchema,
   transferOwnershipResponseSchema,
   transferOwnershipSchema,
   trashedFlowSchema,
@@ -4369,6 +4416,7 @@ export {
   updateOrganizationSchema,
   updatePermissionResponseSchema,
   updatePermissionSchema,
+  usageSchema,
   usedCredentialSchema,
   validateBubbleFlowCodeResponseSchema,
   validateBubbleFlowCodeSchema,