codemie-sdk 0.1.425 → 0.1.427

package/dist/index.js

@@ -72,148 +72,29 @@ var KeycloakCredentials = class {
   }
 };
 
-// src/utils/helpers.ts
-function omitUndefined(obj) {
-  return Object.fromEntries(Object.entries(obj).filter(([_, value]) => value !== void 0));
-}
-
-// src/mappers/assistant.mapper.ts
-var AssistantMapper = class {
-  static mapBaseModelApiResponse(response) {
-    return omitUndefined({
-      generated: response.generated,
-      time_elapsed: response.timeElapsed,
-      tokens_used: response.tokensUsed,
-      thoughts: response.thoughts,
-      task_id: response.taskId
-    });
-  }
-};
-
-// src/services/assistant.ts
-import { z as z2 } from "zod";
-
-// src/schemas/assistant.ts
+// src/schemas/analytics.ts
 import { z } from "zod";
-var AssistantListParamsSchema = z.object({
-  minimal_response: z.boolean().prefault(true),
-  scope: z.enum(["visible_to_user", "marketplace"]).prefault("visible_to_user"),
-  page: z.number().prefault(0),
-  per_page: z.number().prefault(12),
-  filters: z.record(z.string(), z.unknown()).optional()
-}).readonly();
-var PromptVariableSchema = z.object({
-  key: z.string(),
-  description: z.string().optional(),
-  default_value: z.string()
+var TIME_PERIOD_VALUES = [
+  "last_hour",
+  "last_6_hours",
+  "last_24_hours",
+  "last_7_days",
+  "last_30_days",
+  "last_60_days",
+  "last_year"
+];
+var timePeriodSchema = z.enum(TIME_PERIOD_VALUES);
+var analyticsQueryParamsBase = z.object({
+  time_period: timePeriodSchema.optional(),
+  start_date: z.string().datetime({ offset: true }).optional(),
+  end_date: z.string().datetime({ offset: true }).optional(),
+  users: z.string().optional(),
+  projects: z.string().optional()
 });
-var AssistantCreateParamsSchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  icon_url: z.string().optional(),
-  system_prompt: z.string(),
-  project: z.string(),
-  context: z.array(
-    z.object({
-      context_type: z.enum(["knowledge_base", "code"]),
-      name: z.string()
-    })
-  ),
-  llm_model_type: z.string(),
-  toolkits: z.array(
-    z.object({
-      toolkit: z.string(),
-      tools: z.array(
-        z.object({
-          name: z.string(),
-          label: z.string().optional(),
-          settings_config: z.boolean(),
-          user_description: z.string().optional(),
-          settings: z.any().nullable().optional()
-        })
-      ),
-      label: z.string(),
-      settings_config: z.boolean(),
-      is_external: z.boolean(),
-      settings: z.any().optional()
-    })
-  ),
-  conversation_starters: z.array(z.string()),
-  shared: z.boolean().optional(),
-  is_react: z.boolean().optional(),
-  is_global: z.boolean().optional(),
-  slug: z.string().optional(),
-  temperature: z.number().optional(),
-  top_p: z.number().optional(),
-  mcp_servers: z.array(
-    z.object({
-      name: z.string(),
-      description: z.string().optional(),
-      enabled: z.boolean(),
-      config: z.object({
-        url: z.string().optional(),
-        command: z.string().optional(),
-        args: z.array(z.string()).optional(),
-        env: z.record(z.string(), z.unknown()).optional(),
-        auth_token: z.string().optional()
-      }).optional().refine(
-        (config) => {
-          if (!config) {
-            return true;
-          }
-          const hasUrl = !!config.url;
-          const hasCommand = !!config.command;
-          return hasUrl !== hasCommand;
-        },
-        {
-          error: "Either 'url' or 'command' must be provided in config, but not both"
-        }
-      ),
-      mcp_connect_url: z.string().optional(),
-      tools_tokens_size_limit: z.number().optional(),
-      command: z.string().optional(),
-      arguments: z.string().optional(),
-      settings: z.any().optional(),
-      mcp_connect_auth_token: z.any().optional()
-    })
-  ),
-  assistant_ids: z.array(z.string()),
-  prompt_variables: z.array(PromptVariableSchema).optional().prefault([]),
-  categories: z.array(z.string()).max(3).optional(),
-  skip_integration_validation: z.boolean().optional().prefault(false)
-}).readonly();
-var AssistantUpdateParamsSchema = AssistantCreateParamsSchema;
-var AssistantChatParamsSchema = z.object({
-  conversation_id: z.string().optional(),
-  text: z.string(),
-  content_raw: z.string().optional(),
-  file_names: z.array(z.string()).optional(),
-  llm_model: z.string().optional(),
-  history: z.union([
-    z.array(
-      z.object({
-        role: z.enum(["Assistant", "User"]),
-        message: z.string().optional()
-      })
-    ),
-    z.string()
-  ]),
-  history_index: z.number().optional(),
-  stream: z.boolean().optional(),
-  propagate_headers: z.boolean().optional(),
-  custom_metadata: z.record(z.string(), z.unknown()).optional(),
-  top_k: z.number().optional(),
-  system_prompt: z.string().optional(),
-  background_task: z.boolean().optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  mcp_server_single_usage: z.boolean().optional(),
-  save_history: z.boolean().optional(),
-  version: z.number().optional(),
-  output_schema: z.union([z.custom((val) => val instanceof z.ZodType), z.record(z.string(), z.unknown())]).optional()
-}).readonly();
-var AssistantVersionsListParamsSchema = z.object({
-  page: z.number().optional(),
-  per_page: z.number().optional()
+var AnalyticsQueryParamsSchema = analyticsQueryParamsBase.readonly();
+var PaginatedAnalyticsQueryParamsSchema = analyticsQueryParamsBase.extend({
+  page: z.number().int().min(0).default(0),
+  per_page: z.number().int().min(1).default(20)
 }).readonly();
 
 // src/utils/http.ts
@@ -334,6 +215,245 @@ var ApiRequestHandler = class {
   }
 };
 
+// src/services/analytics.ts
+var AnalyticsService = class {
+  constructor(config) {
+    this.api = new ApiRequestHandler(config);
+  }
+  async getSummaries(_params = {}) {
+    const params = AnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/summaries", params);
+  }
+  async getCliSummary(_params = {}) {
+    const params = AnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/cli-summary", params);
+  }
+  async getUsers(_params = {}) {
+    const params = AnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/users", params);
+  }
+  async getAssistantsChats(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/assistants-chats", params);
+  }
+  async getWorkflows(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/workflows", params);
+  }
+  async getToolsUsage(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/tools-usage", params);
+  }
+  async getWebhooksInvocation(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/webhooks-invocation", params);
+  }
+  async getMcpServers(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/mcp-servers", params);
+  }
+  async getMcpServersByUsers(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/mcp-servers-by-users", params);
+  }
+  async getProjectsSpending(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/projects-spending", params);
+  }
+  async getLlmsUsage(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/llms-usage", params);
+  }
+  async getUsersSpending(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/users-spending", params);
+  }
+  async getBudgetSoftLimit(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/budget-soft-limit", params);
+  }
+  async getBudgetHardLimit(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/budget-hard-limit", params);
+  }
+  async getUsersActivity(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/users-activity", params);
+  }
+  async getProjectsActivity(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/projects-activity", params);
+  }
+  async getAgentsUsage(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/agents-usage", params);
+  }
+  async getCliAgents(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/cli-agents", params);
+  }
+  async getCliLlms(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/cli-llms", params);
+  }
+  async getCliUsers(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/cli-users", params);
+  }
+  async getCliErrors(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/cli-errors", params);
+  }
+  async getCliRepositories(_params = {}) {
+    const params = PaginatedAnalyticsQueryParamsSchema.parse(_params);
+    return this.api.get("/v1/analytics/cli-repositories", params);
+  }
+};
+
+// src/utils/helpers.ts
+function omitUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([_, value]) => value !== void 0));
+}
+
+// src/mappers/assistant.mapper.ts
+var AssistantMapper = class {
+  static mapBaseModelApiResponse(response) {
+    return omitUndefined({
+      generated: response.generated,
+      time_elapsed: response.timeElapsed,
+      tokens_used: response.tokensUsed,
+      thoughts: response.thoughts,
+      task_id: response.taskId
+    });
+  }
+};
+
+// src/services/assistant.ts
+import { z as z3 } from "zod";
+
+// src/schemas/assistant.ts
+import { z as z2 } from "zod";
+var AssistantListParamsSchema = z2.object({
+  minimal_response: z2.boolean().prefault(true),
+  scope: z2.enum(["visible_to_user", "marketplace"]).prefault("visible_to_user"),
+  page: z2.number().prefault(0),
+  per_page: z2.number().prefault(12),
+  filters: z2.record(z2.string(), z2.unknown()).optional()
+}).readonly();
+var PromptVariableSchema = z2.object({
+  key: z2.string(),
+  description: z2.string().optional(),
+  default_value: z2.string()
+});
+var AssistantCreateParamsSchema = z2.object({
+  name: z2.string(),
+  description: z2.string(),
+  icon_url: z2.string().optional(),
+  system_prompt: z2.string(),
+  project: z2.string(),
+  context: z2.array(
+    z2.object({
+      context_type: z2.enum(["knowledge_base", "code"]),
+      name: z2.string()
+    })
+  ),
+  llm_model_type: z2.string(),
+  toolkits: z2.array(
+    z2.object({
+      toolkit: z2.string(),
+      tools: z2.array(
+        z2.object({
+          name: z2.string(),
+          label: z2.string().optional(),
+          settings_config: z2.boolean(),
+          user_description: z2.string().optional(),
+          settings: z2.any().nullable().optional()
+        })
+      ),
+      label: z2.string(),
+      settings_config: z2.boolean(),
+      is_external: z2.boolean(),
+      settings: z2.any().optional()
+    })
+  ),
+  conversation_starters: z2.array(z2.string()),
+  shared: z2.boolean().optional(),
+  is_react: z2.boolean().optional(),
+  is_global: z2.boolean().optional(),
+  slug: z2.string().optional(),
+  temperature: z2.number().optional(),
+  top_p: z2.number().optional(),
+  mcp_servers: z2.array(
+    z2.object({
+      name: z2.string(),
+      description: z2.string().optional(),
+      enabled: z2.boolean(),
+      config: z2.object({
+        url: z2.string().optional(),
+        command: z2.string().optional(),
+        args: z2.array(z2.string()).optional(),
+        env: z2.record(z2.string(), z2.unknown()).optional(),
+        auth_token: z2.string().optional()
+      }).optional().refine(
+        (config) => {
+          if (!config) {
+            return true;
+          }
+          const hasUrl = !!config.url;
+          const hasCommand = !!config.command;
+          return hasUrl !== hasCommand;
+        },
+        {
+          error: "Either 'url' or 'command' must be provided in config, but not both"
+        }
+      ),
+      mcp_connect_url: z2.string().optional(),
+      tools_tokens_size_limit: z2.number().optional(),
+      command: z2.string().optional(),
+      arguments: z2.string().optional(),
+      settings: z2.any().optional(),
+      mcp_connect_auth_token: z2.any().optional()
+    })
+  ),
+  assistant_ids: z2.array(z2.string()),
+  prompt_variables: z2.array(PromptVariableSchema).optional().prefault([]),
+  categories: z2.array(z2.string()).max(3).optional(),
+  skip_integration_validation: z2.boolean().optional().prefault(false)
+}).readonly();
+var AssistantUpdateParamsSchema = AssistantCreateParamsSchema;
+var AssistantChatParamsSchema = z2.object({
+  conversation_id: z2.string().optional(),
+  text: z2.string(),
+  content_raw: z2.string().optional(),
+  file_names: z2.array(z2.string()).optional(),
+  llm_model: z2.string().optional(),
+  history: z2.union([
+    z2.array(
+      z2.object({
+        role: z2.enum(["Assistant", "User"]),
+        message: z2.string().optional()
+      })
+    ),
+    z2.string()
+  ]),
+  history_index: z2.number().optional(),
+  stream: z2.boolean().optional(),
+  propagate_headers: z2.boolean().optional(),
+  custom_metadata: z2.record(z2.string(), z2.unknown()).optional(),
+  top_k: z2.number().optional(),
+  system_prompt: z2.string().optional(),
+  background_task: z2.boolean().optional(),
+  metadata: z2.record(z2.string(), z2.unknown()).optional(),
+  mcp_server_single_usage: z2.boolean().optional(),
+  save_history: z2.boolean().optional(),
+  version: z2.number().optional(),
+  output_schema: z2.union([z2.custom((val) => val instanceof z2.ZodType), z2.record(z2.string(), z2.unknown())]).optional()
+}).readonly();
+var AssistantVersionsListParamsSchema = z2.object({
+  page: z2.number().optional(),
+  per_page: z2.number().optional()
+}).readonly();
+
 // src/services/assistant.ts
 var AssistantService = class {
   constructor(config) {
@@ -464,9 +584,9 @@ var AssistantService = class {
   async chat(assistantId, _params, headers) {
     let zodSchema = void 0;
     let params = { ..._params };
-    if (params.output_schema && params.output_schema instanceof z2.ZodType) {
+    if (params.output_schema && params.output_schema instanceof z3.ZodType) {
       zodSchema = params.output_schema;
-      params.output_schema = z2.toJSONSchema(zodSchema);
+      params.output_schema = z3.toJSONSchema(zodSchema);
     }
     params = AssistantChatParamsSchema.parse(params);
     const response = await this.api.post(
@@ -489,9 +609,9 @@ var AssistantService = class {
   async chatBySlug(assistantSlug, _params, headers) {
     let zodSchema = void 0;
     let params = { ..._params };
-    if (params.output_schema && params.output_schema instanceof z2.ZodType) {
+    if (params.output_schema && params.output_schema instanceof z3.ZodType) {
       zodSchema = params.output_schema;
-      params.output_schema = z2.toJSONSchema(zodSchema);
+      params.output_schema = z3.toJSONSchema(zodSchema);
     }
     params = AssistantChatParamsSchema.parse(params);
     const response = await this.api.post(
@@ -531,9 +651,9 @@ var AssistantService = class {
   async chatWithVersion(assistantId, versionNumber, _params) {
     let zodSchema = void 0;
     let params = { ..._params };
-    if (params.output_schema && params.output_schema instanceof z2.ZodType) {
+    if (params.output_schema && params.output_schema instanceof z3.ZodType) {
       zodSchema = params.output_schema;
-      params.output_schema = z2.toJSONSchema(zodSchema);
+      params.output_schema = z3.toJSONSchema(zodSchema);
     }
     params = AssistantChatParamsSchema.parse(params);
     const response = await this.api.post(
@@ -552,11 +672,11 @@ var AssistantService = class {
 };
 
 // src/schemas/conversation.ts
-import { z as z3 } from "zod";
-var ConversationCreateParamsSchema = z3.object({
-  initial_assistant_id: z3.string().optional(),
-  folder: z3.string().optional(),
-  mcp_server_single_usage: z3.boolean().prefault(false).optional()
+import { z as z4 } from "zod";
+var ConversationCreateParamsSchema = z4.object({
+  initial_assistant_id: z4.string().optional(),
+  folder: z4.string().optional(),
+  mcp_server_single_usage: z4.boolean().prefault(false).optional()
 }).readonly();
 
 // src/services/conversation.ts
@@ -1110,35 +1230,35 @@ var IntegrationType = {
 };
 
 // src/schemas/integration.ts
-import { z as z4 } from "zod";
-var IntegrationListParamsSchema = z4.object({
-  setting_type: z4.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER),
-  page: z4.number().prefault(0),
-  per_page: z4.number().prefault(10),
-  filters: z4.record(z4.string(), z4.unknown()).optional()
+import { z as z5 } from "zod";
+var IntegrationListParamsSchema = z5.object({
+  setting_type: z5.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER),
+  page: z5.number().prefault(0),
+  per_page: z5.number().prefault(10),
+  filters: z5.record(z5.string(), z5.unknown()).optional()
 }).readonly();
-var IntegrationGetParamsSchema = z4.object({
-  integration_id: z4.string(),
-  setting_type: z4.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER)
+var IntegrationGetParamsSchema = z5.object({
+  integration_id: z5.string(),
+  setting_type: z5.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER)
 }).readonly();
-var IntegrationGetByAliasParamsSchema = z4.object({
-  alias: z4.string(),
-  setting_type: z4.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER)
+var IntegrationGetByAliasParamsSchema = z5.object({
+  alias: z5.string(),
+  setting_type: z5.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER)
 }).readonly();
-var CredentialValueSchema = z4.object({
-  key: z4.string(),
-  value: z4.unknown()
+var CredentialValueSchema = z5.object({
+  key: z5.string(),
+  value: z5.unknown()
 });
-var IntegrationCreateParamsSchema = z4.object({
-  credential_type: z4.enum(Object.values(CredentialTypes)),
-  credential_values: z4.array(CredentialValueSchema),
-  project_name: z4.string(),
-  setting_type: z4.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER),
-  alias: z4.string().optional(),
-  default: z4.boolean().optional().prefault(false),
-  project: z4.string().optional(),
-  enabled: z4.boolean().optional().prefault(true),
-  external_id: z4.string().optional()
+var IntegrationCreateParamsSchema = z5.object({
+  credential_type: z5.enum(Object.values(CredentialTypes)),
+  credential_values: z5.array(CredentialValueSchema),
+  project_name: z5.string(),
+  setting_type: z5.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER),
+  alias: z5.string().optional(),
+  default: z5.boolean().optional().prefault(false),
+  project: z5.string().optional(),
+  enabled: z5.boolean().optional().prefault(true),
+  external_id: z5.string().optional()
 }).readonly();
 var IntegrationUpdateParamsSchema = IntegrationCreateParamsSchema;
 
@@ -1364,7 +1484,7 @@ var CategoryService = class {
 };
 
 // src/schemas/skill.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/models/skill.ts
 var SkillVisibility = /* @__PURE__ */ ((SkillVisibility2) => {
@@ -1416,13 +1536,13 @@ var SkillCategory = /* @__PURE__ */ ((SkillCategory2) => {
 })(SkillCategory || {});
 
 // src/schemas/skill.ts
-var SkillListParamsSchema = z5.object({
-  page: z5.number().default(0),
-  per_page: z5.number().default(20),
-  filters: z5.record(z5.string(), z5.unknown()).optional(),
-  sort_by: z5.nativeEnum(SkillSortBy).optional(),
-  scope: z5.nativeEnum(SkillScopeFilter).optional(),
-  assistant_id: z5.string().optional()
+var SkillListParamsSchema = z6.object({
+  page: z6.number().default(0),
+  per_page: z6.number().default(20),
+  filters: z6.record(z6.string(), z6.unknown()).optional(),
+  sort_by: z6.nativeEnum(SkillSortBy).optional(),
+  scope: z6.nativeEnum(SkillScopeFilter).optional(),
+  assistant_id: z6.string().optional()
 }).readonly();
 
 // src/services/skill.ts
@@ -1589,7 +1709,7 @@ var WorkflowMapper = class {
 };
 
 // src/schemas/workflow.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/models/workflow.ts
 var WorkflowMode = {
@@ -1606,50 +1726,50 @@ var ExecutionStatus = {
 };
 
 // src/schemas/workflow.ts
-var WorkflowListParamsSchema = z6.object({
-  page: z6.number().prefault(0),
-  per_page: z6.number().prefault(10),
-  projects: z6.array(z6.string()).optional(),
-  search: z6.string().optional()
+var WorkflowListParamsSchema = z7.object({
+  page: z7.number().prefault(0),
+  per_page: z7.number().prefault(10),
+  projects: z7.array(z7.string()).optional(),
+  search: z7.string().optional()
 }).readonly();
-var WorkflowCreateParamsSchema = z6.object({
-  project: z6.string(),
-  name: z6.string(),
-  description: z6.string().optional(),
-  yaml_config: z6.string(),
-  mode: z6.enum([WorkflowMode.SEQUENTIAL, WorkflowMode.AUTONOMOUS]),
-  shared: z6.boolean(),
-  icon_url: z6.string().optional()
+var WorkflowCreateParamsSchema = z7.object({
+  project: z7.string(),
+  name: z7.string(),
+  description: z7.string().optional(),
+  yaml_config: z7.string(),
+  mode: z7.enum([WorkflowMode.SEQUENTIAL, WorkflowMode.AUTONOMOUS]),
+  shared: z7.boolean(),
+  icon_url: z7.string().optional()
 }).readonly();
-var WorkflowUpdateParamsSchema = z6.object({
-  project: z6.string(),
-  name: z6.string(),
-  description: z6.string().optional(),
-  yaml_config: z6.string(),
-  mode: z6.enum([WorkflowMode.SEQUENTIAL, WorkflowMode.AUTONOMOUS]).optional(),
-  shared: z6.boolean().optional(),
-  icon_url: z6.string().optional()
+var WorkflowUpdateParamsSchema = z7.object({
+  project: z7.string(),
+  name: z7.string(),
+  description: z7.string().optional(),
+  yaml_config: z7.string(),
+  mode: z7.enum([WorkflowMode.SEQUENTIAL, WorkflowMode.AUTONOMOUS]).optional(),
+  shared: z7.boolean().optional(),
+  icon_url: z7.string().optional()
 }).readonly();
-var WorkflowExecutionListParamsSchema = z6.object({
-  page: z6.number().prefault(0),
-  per_page: z6.number().prefault(10)
+var WorkflowExecutionListParamsSchema = z7.object({
+  page: z7.number().prefault(0),
+  per_page: z7.number().prefault(10)
 }).readonly();
-var WorkflowExecutionCreateParamsSchema = z6.object({
-  user_input: z6.union([
-    z6.string(),
-    z6.record(z6.string(), z6.unknown()),
-    z6.array(z6.unknown()),
-    z6.number(),
-    z6.boolean()
+var WorkflowExecutionCreateParamsSchema = z7.object({
+  user_input: z7.union([
+    z7.string(),
+    z7.record(z7.string(), z7.unknown()),
+    z7.array(z7.unknown()),
+    z7.number(),
+    z7.boolean()
   ]).optional(),
-  file_name: z6.string().optional(),
-  session_id: z6.string().optional(),
-  propagate_headers: z6.boolean().optional(),
-  tags: z6.array(z6.string()).optional()
+  file_name: z7.string().optional(),
+  session_id: z7.string().optional(),
+  propagate_headers: z7.boolean().optional(),
+  tags: z7.array(z7.string()).optional()
 }).readonly();
-var WorkflowExecutionStateListParamsSchema = z6.object({
-  page: z6.number().prefault(0),
-  per_page: z6.number().prefault(10)
+var WorkflowExecutionStateListParamsSchema = z7.object({
+  page: z7.number().prefault(0),
+  per_page: z7.number().prefault(10)
 }).readonly();
 
 // src/services/workflow_execution_state.ts
@@ -1886,6 +2006,7 @@ var CodeMieClient = class {
       verifySSL: this.verifySSL,
       cookies: this.cookies
     };
+    this._analytics = new AnalyticsService(authConfig);
     this._assistants = new AssistantService(authConfig);
     this._conversations = new ConversationService(authConfig);
     this._datasources = new DatasourceService(authConfig);
@@ -1898,6 +2019,12 @@ var CodeMieClient = class {
     this._skills = new SkillService(authConfig);
     this._workflows = new WorkflowService(authConfig);
   }
+  /**
+   * Get the AnalyticsService instance.
+   */
+  get analytics() {
+    return this._analytics;
+  }
   /**
    * Get the AssistantService instance.
    */
@@ -2027,6 +2154,7 @@ var CodeMieClient = class {
       verifySSL: this.verifySSL,
       cookies: this.cookies
     };
+    this._analytics = new AnalyticsService(authConfig);
     this._assistants = new AssistantService(authConfig);
     this._conversations = new ConversationService(authConfig);
     this._datasources = new DatasourceService(authConfig);
@@ -2204,6 +2332,8 @@ var BackgroundTaskStatus = {
   FAILED: "FAILED"
 };
 export {
+  AnalyticsQueryParamsSchema,
+  AnalyticsService,
   ApiError,
   AssistantChatParamsSchema,
   AssistantCreateParamsSchema,
@@ -2241,11 +2371,13 @@ export {
   LLMProvider,
   LLMService,
   NotFoundError,
+  PaginatedAnalyticsQueryParamsSchema,
   SkillCategory,
   SkillScopeFilter,
   SkillService,
   SkillSortBy,
   SkillVisibility,
+  TIME_PERIOD_VALUES,
   TaskService,
   UserService,
   WorkflowCreateParamsSchema,