codemie-sdk 0.1.425 → 0.1.426

package/dist/index.cjs

@@ -30,6 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AnalyticsQueryParamsSchema: () => AnalyticsQueryParamsSchema,
+  AnalyticsService: () => AnalyticsService,
   ApiError: () => ApiError,
   AssistantChatParamsSchema: () => AssistantChatParamsSchema,
   AssistantCreateParamsSchema: () => AssistantCreateParamsSchema,
@@ -67,11 +69,13 @@ __export(index_exports, {
   LLMProvider: () => LLMProvider,
   LLMService: () => LLMService,
   NotFoundError: () => NotFoundError,
+  PaginatedAnalyticsQueryParamsSchema: () => PaginatedAnalyticsQueryParamsSchema,
   SkillCategory: () => SkillCategory,
   SkillScopeFilter: () => SkillScopeFilter,
   SkillService: () => SkillService,
   SkillSortBy: () => SkillSortBy,
   SkillVisibility: () => SkillVisibility,
+  TIME_PERIOD_VALUES: () => TIME_PERIOD_VALUES,
   TaskService: () => TaskService,
   UserService: () => UserService,
   WorkflowCreateParamsSchema: () => WorkflowCreateParamsSchema,
@@ -168,148 +172,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
-var import_zod2 = require("zod");
-
-// src/schemas/assistant.ts
+// src/schemas/analytics.ts
 var import_zod = require("zod");
-var AssistantListParamsSchema = import_zod.z.object({
-  minimal_response: import_zod.z.boolean().prefault(true),
-  scope: import_zod.z.enum(["visible_to_user", "marketplace"]).prefault("visible_to_user"),
-  page: import_zod.z.number().prefault(0),
-  per_page: import_zod.z.number().prefault(12),
-  filters: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
-}).readonly();
-var PromptVariableSchema = import_zod.z.object({
-  key: import_zod.z.string(),
-  description: import_zod.z.string().optional(),
-  default_value: import_zod.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 = import_zod.z.enum(TIME_PERIOD_VALUES);
+var analyticsQueryParamsBase = import_zod.z.object({
+  time_period: timePeriodSchema.optional(),
+  start_date: import_zod.z.string().datetime({ offset: true }).optional(),
+  end_date: import_zod.z.string().datetime({ offset: true }).optional(),
+  users: import_zod.z.string().optional(),
+  projects: import_zod.z.string().optional()
 });
-var AssistantCreateParamsSchema = import_zod.z.object({
-  name: import_zod.z.string(),
-  description: import_zod.z.string(),
-  icon_url: import_zod.z.string().optional(),
-  system_prompt: import_zod.z.string(),
-  project: import_zod.z.string(),
-  context: import_zod.z.array(
-    import_zod.z.object({
-      context_type: import_zod.z.enum(["knowledge_base", "code"]),
-      name: import_zod.z.string()
-    })
-  ),
-  llm_model_type: import_zod.z.string(),
-  toolkits: import_zod.z.array(
-    import_zod.z.object({
-      toolkit: import_zod.z.string(),
-      tools: import_zod.z.array(
-        import_zod.z.object({
-          name: import_zod.z.string(),
-          label: import_zod.z.string().optional(),
-          settings_config: import_zod.z.boolean(),
-          user_description: import_zod.z.string().optional(),
-          settings: import_zod.z.any().nullable().optional()
-        })
-      ),
-      label: import_zod.z.string(),
-      settings_config: import_zod.z.boolean(),
-      is_external: import_zod.z.boolean(),
-      settings: import_zod.z.any().optional()
-    })
-  ),
-  conversation_starters: import_zod.z.array(import_zod.z.string()),
-  shared: import_zod.z.boolean().optional(),
-  is_react: import_zod.z.boolean().optional(),
-  is_global: import_zod.z.boolean().optional(),
-  slug: import_zod.z.string().optional(),
-  temperature: import_zod.z.number().optional(),
-  top_p: import_zod.z.number().optional(),
-  mcp_servers: import_zod.z.array(
-    import_zod.z.object({
-      name: import_zod.z.string(),
-      description: import_zod.z.string().optional(),
-      enabled: import_zod.z.boolean(),
-      config: import_zod.z.object({
-        url: import_zod.z.string().optional(),
-        command: import_zod.z.string().optional(),
-        args: import_zod.z.array(import_zod.z.string()).optional(),
-        env: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
-        auth_token: import_zod.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: import_zod.z.string().optional(),
-      tools_tokens_size_limit: import_zod.z.number().optional(),
-      command: import_zod.z.string().optional(),
-      arguments: import_zod.z.string().optional(),
-      settings: import_zod.z.any().optional(),
-      mcp_connect_auth_token: import_zod.z.any().optional()
-    })
-  ),
-  assistant_ids: import_zod.z.array(import_zod.z.string()),
-  prompt_variables: import_zod.z.array(PromptVariableSchema).optional().prefault([]),
-  categories: import_zod.z.array(import_zod.z.string()).max(3).optional(),
-  skip_integration_validation: import_zod.z.boolean().optional().prefault(false)
-}).readonly();
-var AssistantUpdateParamsSchema = AssistantCreateParamsSchema;
-var AssistantChatParamsSchema = import_zod.z.object({
-  conversation_id: import_zod.z.string().optional(),
-  text: import_zod.z.string(),
-  content_raw: import_zod.z.string().optional(),
-  file_names: import_zod.z.array(import_zod.z.string()).optional(),
-  llm_model: import_zod.z.string().optional(),
-  history: import_zod.z.union([
-    import_zod.z.array(
-      import_zod.z.object({
-        role: import_zod.z.enum(["Assistant", "User"]),
-        message: import_zod.z.string().optional()
-      })
-    ),
-    import_zod.z.string()
-  ]),
-  history_index: import_zod.z.number().optional(),
-  stream: import_zod.z.boolean().optional(),
-  propagate_headers: import_zod.z.boolean().optional(),
-  custom_metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
-  top_k: import_zod.z.number().optional(),
-  system_prompt: import_zod.z.string().optional(),
-  background_task: import_zod.z.boolean().optional(),
-  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
-  mcp_server_single_usage: import_zod.z.boolean().optional(),
-  save_history: import_zod.z.boolean().optional(),
-  version: import_zod.z.number().optional(),
-  output_schema: import_zod.z.union([import_zod.z.custom((val) => val instanceof import_zod.z.ZodType), import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())]).optional()
-}).readonly();
-var AssistantVersionsListParamsSchema = import_zod.z.object({
-  page: import_zod.z.number().optional(),
-  per_page: import_zod.z.number().optional()
+var AnalyticsQueryParamsSchema = analyticsQueryParamsBase.readonly();
+var PaginatedAnalyticsQueryParamsSchema = analyticsQueryParamsBase.extend({
+  page: import_zod.z.number().int().min(0).default(0),
+  per_page: import_zod.z.number().int().min(1).default(20)
 }).readonly();
 
 // src/utils/http.ts
@@ -430,6 +315,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
+var import_zod3 = require("zod");
+
+// src/schemas/assistant.ts
+var import_zod2 = require("zod");
+var AssistantListParamsSchema = import_zod2.z.object({
+  minimal_response: import_zod2.z.boolean().prefault(true),
+  scope: import_zod2.z.enum(["visible_to_user", "marketplace"]).prefault("visible_to_user"),
+  page: import_zod2.z.number().prefault(0),
+  per_page: import_zod2.z.number().prefault(12),
+  filters: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional()
+}).readonly();
+var PromptVariableSchema = import_zod2.z.object({
+  key: import_zod2.z.string(),
+  description: import_zod2.z.string().optional(),
+  default_value: import_zod2.z.string()
+});
+var AssistantCreateParamsSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  description: import_zod2.z.string(),
+  icon_url: import_zod2.z.string().optional(),
+  system_prompt: import_zod2.z.string(),
+  project: import_zod2.z.string(),
+  context: import_zod2.z.array(
+    import_zod2.z.object({
+      context_type: import_zod2.z.enum(["knowledge_base", "code"]),
+      name: import_zod2.z.string()
+    })
+  ),
+  llm_model_type: import_zod2.z.string(),
+  toolkits: import_zod2.z.array(
+    import_zod2.z.object({
+      toolkit: import_zod2.z.string(),
+      tools: import_zod2.z.array(
+        import_zod2.z.object({
+          name: import_zod2.z.string(),
+          label: import_zod2.z.string().optional(),
+          settings_config: import_zod2.z.boolean(),
+          user_description: import_zod2.z.string().optional(),
+          settings: import_zod2.z.any().nullable().optional()
+        })
+      ),
+      label: import_zod2.z.string(),
+      settings_config: import_zod2.z.boolean(),
+      is_external: import_zod2.z.boolean(),
+      settings: import_zod2.z.any().optional()
+    })
+  ),
+  conversation_starters: import_zod2.z.array(import_zod2.z.string()),
+  shared: import_zod2.z.boolean().optional(),
+  is_react: import_zod2.z.boolean().optional(),
+  is_global: import_zod2.z.boolean().optional(),
+  slug: import_zod2.z.string().optional(),
+  temperature: import_zod2.z.number().optional(),
+  top_p: import_zod2.z.number().optional(),
+  mcp_servers: import_zod2.z.array(
+    import_zod2.z.object({
+      name: import_zod2.z.string(),
+      description: import_zod2.z.string().optional(),
+      enabled: import_zod2.z.boolean(),
+      config: import_zod2.z.object({
+        url: import_zod2.z.string().optional(),
+        command: import_zod2.z.string().optional(),
+        args: import_zod2.z.array(import_zod2.z.string()).optional(),
+        env: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
+        auth_token: import_zod2.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: import_zod2.z.string().optional(),
+      tools_tokens_size_limit: import_zod2.z.number().optional(),
+      command: import_zod2.z.string().optional(),
+      arguments: import_zod2.z.string().optional(),
+      settings: import_zod2.z.any().optional(),
+      mcp_connect_auth_token: import_zod2.z.any().optional()
+    })
+  ),
+  assistant_ids: import_zod2.z.array(import_zod2.z.string()),
+  prompt_variables: import_zod2.z.array(PromptVariableSchema).optional().prefault([]),
+  categories: import_zod2.z.array(import_zod2.z.string()).max(3).optional(),
+  skip_integration_validation: import_zod2.z.boolean().optional().prefault(false)
+}).readonly();
+var AssistantUpdateParamsSchema = AssistantCreateParamsSchema;
+var AssistantChatParamsSchema = import_zod2.z.object({
+  conversation_id: import_zod2.z.string().optional(),
+  text: import_zod2.z.string(),
+  content_raw: import_zod2.z.string().optional(),
+  file_names: import_zod2.z.array(import_zod2.z.string()).optional(),
+  llm_model: import_zod2.z.string().optional(),
+  history: import_zod2.z.union([
+    import_zod2.z.array(
+      import_zod2.z.object({
+        role: import_zod2.z.enum(["Assistant", "User"]),
+        message: import_zod2.z.string().optional()
+      })
+    ),
+    import_zod2.z.string()
+  ]),
+  history_index: import_zod2.z.number().optional(),
+  stream: import_zod2.z.boolean().optional(),
+  propagate_headers: import_zod2.z.boolean().optional(),
+  custom_metadata: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
+  top_k: import_zod2.z.number().optional(),
+  system_prompt: import_zod2.z.string().optional(),
+  background_task: import_zod2.z.boolean().optional(),
+  metadata: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
+  mcp_server_single_usage: import_zod2.z.boolean().optional(),
+  save_history: import_zod2.z.boolean().optional(),
+  version: import_zod2.z.number().optional(),
+  output_schema: import_zod2.z.union([import_zod2.z.custom((val) => val instanceof import_zod2.z.ZodType), import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown())]).optional()
+}).readonly();
+var AssistantVersionsListParamsSchema = import_zod2.z.object({
+  page: import_zod2.z.number().optional(),
+  per_page: import_zod2.z.number().optional()
+}).readonly();
+
 // src/services/assistant.ts
 var AssistantService = class {
   constructor(config) {
@@ -560,9 +684,9 @@ var AssistantService = class {
   async chat(assistantId, _params, headers) {
     let zodSchema = void 0;
     let params = { ..._params };
-    if (params.output_schema && params.output_schema instanceof import_zod2.z.ZodType) {
+    if (params.output_schema && params.output_schema instanceof import_zod3.z.ZodType) {
       zodSchema = params.output_schema;
-      params.output_schema = import_zod2.z.toJSONSchema(zodSchema);
+      params.output_schema = import_zod3.z.toJSONSchema(zodSchema);
     }
     params = AssistantChatParamsSchema.parse(params);
     const response = await this.api.post(
@@ -585,9 +709,9 @@ var AssistantService = class {
   async chatBySlug(assistantSlug, _params, headers) {
     let zodSchema = void 0;
     let params = { ..._params };
-    if (params.output_schema && params.output_schema instanceof import_zod2.z.ZodType) {
+    if (params.output_schema && params.output_schema instanceof import_zod3.z.ZodType) {
       zodSchema = params.output_schema;
-      params.output_schema = import_zod2.z.toJSONSchema(zodSchema);
+      params.output_schema = import_zod3.z.toJSONSchema(zodSchema);
     }
     params = AssistantChatParamsSchema.parse(params);
     const response = await this.api.post(
@@ -627,9 +751,9 @@ var AssistantService = class {
   async chatWithVersion(assistantId, versionNumber, _params) {
     let zodSchema = void 0;
     let params = { ..._params };
-    if (params.output_schema && params.output_schema instanceof import_zod2.z.ZodType) {
+    if (params.output_schema && params.output_schema instanceof import_zod3.z.ZodType) {
       zodSchema = params.output_schema;
-      params.output_schema = import_zod2.z.toJSONSchema(zodSchema);
+      params.output_schema = import_zod3.z.toJSONSchema(zodSchema);
     }
     params = AssistantChatParamsSchema.parse(params);
     const response = await this.api.post(
@@ -648,11 +772,11 @@ var AssistantService = class {
 };
 
 // src/schemas/conversation.ts
-var import_zod3 = require("zod");
-var ConversationCreateParamsSchema = import_zod3.z.object({
-  initial_assistant_id: import_zod3.z.string().optional(),
-  folder: import_zod3.z.string().optional(),
-  mcp_server_single_usage: import_zod3.z.boolean().prefault(false).optional()
+var import_zod4 = require("zod");
+var ConversationCreateParamsSchema = import_zod4.z.object({
+  initial_assistant_id: import_zod4.z.string().optional(),
+  folder: import_zod4.z.string().optional(),
+  mcp_server_single_usage: import_zod4.z.boolean().prefault(false).optional()
 }).readonly();
 
 // src/services/conversation.ts
@@ -1206,35 +1330,35 @@ var IntegrationType = {
 };
 
 // src/schemas/integration.ts
-var import_zod4 = require("zod");
-var IntegrationListParamsSchema = import_zod4.z.object({
-  setting_type: import_zod4.z.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER),
-  page: import_zod4.z.number().prefault(0),
-  per_page: import_zod4.z.number().prefault(10),
-  filters: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional()
+var import_zod5 = require("zod");
+var IntegrationListParamsSchema = import_zod5.z.object({
+  setting_type: import_zod5.z.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER),
+  page: import_zod5.z.number().prefault(0),
+  per_page: import_zod5.z.number().prefault(10),
+  filters: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).optional()
 }).readonly();
-var IntegrationGetParamsSchema = import_zod4.z.object({
-  integration_id: import_zod4.z.string(),
-  setting_type: import_zod4.z.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER)
+var IntegrationGetParamsSchema = import_zod5.z.object({
+  integration_id: import_zod5.z.string(),
+  setting_type: import_zod5.z.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER)
 }).readonly();
-var IntegrationGetByAliasParamsSchema = import_zod4.z.object({
-  alias: import_zod4.z.string(),
-  setting_type: import_zod4.z.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER)
+var IntegrationGetByAliasParamsSchema = import_zod5.z.object({
+  alias: import_zod5.z.string(),
+  setting_type: import_zod5.z.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER)
 }).readonly();
-var CredentialValueSchema = import_zod4.z.object({
-  key: import_zod4.z.string(),
-  value: import_zod4.z.unknown()
+var CredentialValueSchema = import_zod5.z.object({
+  key: import_zod5.z.string(),
+  value: import_zod5.z.unknown()
 });
-var IntegrationCreateParamsSchema = import_zod4.z.object({
-  credential_type: import_zod4.z.enum(Object.values(CredentialTypes)),
-  credential_values: import_zod4.z.array(CredentialValueSchema),
-  project_name: import_zod4.z.string(),
-  setting_type: import_zod4.z.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER),
-  alias: import_zod4.z.string().optional(),
-  default: import_zod4.z.boolean().optional().prefault(false),
-  project: import_zod4.z.string().optional(),
-  enabled: import_zod4.z.boolean().optional().prefault(true),
-  external_id: import_zod4.z.string().optional()
+var IntegrationCreateParamsSchema = import_zod5.z.object({
+  credential_type: import_zod5.z.enum(Object.values(CredentialTypes)),
+  credential_values: import_zod5.z.array(CredentialValueSchema),
+  project_name: import_zod5.z.string(),
+  setting_type: import_zod5.z.enum([IntegrationType.USER, IntegrationType.PROJECT]).prefault(IntegrationType.USER),
+  alias: import_zod5.z.string().optional(),
+  default: import_zod5.z.boolean().optional().prefault(false),
+  project: import_zod5.z.string().optional(),
+  enabled: import_zod5.z.boolean().optional().prefault(true),
+  external_id: import_zod5.z.string().optional()
 }).readonly();
 var IntegrationUpdateParamsSchema = IntegrationCreateParamsSchema;
 
@@ -1460,7 +1584,7 @@ var CategoryService = class {
 };
 
 // src/schemas/skill.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 
 // src/models/skill.ts
 var SkillVisibility = /* @__PURE__ */ ((SkillVisibility2) => {
@@ -1512,13 +1636,13 @@ var SkillCategory = /* @__PURE__ */ ((SkillCategory2) => {
 })(SkillCategory || {});
 
 // src/schemas/skill.ts
-var SkillListParamsSchema = import_zod5.z.object({
-  page: import_zod5.z.number().default(0),
-  per_page: import_zod5.z.number().default(20),
-  filters: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).optional(),
-  sort_by: import_zod5.z.nativeEnum(SkillSortBy).optional(),
-  scope: import_zod5.z.nativeEnum(SkillScopeFilter).optional(),
-  assistant_id: import_zod5.z.string().optional()
+var SkillListParamsSchema = import_zod6.z.object({
+  page: import_zod6.z.number().default(0),
+  per_page: import_zod6.z.number().default(20),
+  filters: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).optional(),
+  sort_by: import_zod6.z.nativeEnum(SkillSortBy).optional(),
+  scope: import_zod6.z.nativeEnum(SkillScopeFilter).optional(),
+  assistant_id: import_zod6.z.string().optional()
 }).readonly();
 
 // src/services/skill.ts
@@ -1685,7 +1809,7 @@ var WorkflowMapper = class {
 };
 
 // src/schemas/workflow.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // src/models/workflow.ts
 var WorkflowMode = {
@@ -1702,50 +1826,50 @@ var ExecutionStatus = {
 };
 
 // src/schemas/workflow.ts
-var WorkflowListParamsSchema = import_zod6.z.object({
-  page: import_zod6.z.number().prefault(0),
-  per_page: import_zod6.z.number().prefault(10),
-  projects: import_zod6.z.array(import_zod6.z.string()).optional(),
-  search: import_zod6.z.string().optional()
+var WorkflowListParamsSchema = import_zod7.z.object({
+  page: import_zod7.z.number().prefault(0),
+  per_page: import_zod7.z.number().prefault(10),
+  projects: import_zod7.z.array(import_zod7.z.string()).optional(),
+  search: import_zod7.z.string().optional()
 }).readonly();
-var WorkflowCreateParamsSchema = import_zod6.z.object({
-  project: import_zod6.z.string(),
-  name: import_zod6.z.string(),
-  description: import_zod6.z.string().optional(),
-  yaml_config: import_zod6.z.string(),
-  mode: import_zod6.z.enum([WorkflowMode.SEQUENTIAL, WorkflowMode.AUTONOMOUS]),
-  shared: import_zod6.z.boolean(),
-  icon_url: import_zod6.z.string().optional()
+var WorkflowCreateParamsSchema = import_zod7.z.object({
+  project: import_zod7.z.string(),
+  name: import_zod7.z.string(),
+  description: import_zod7.z.string().optional(),
+  yaml_config: import_zod7.z.string(),
+  mode: import_zod7.z.enum([WorkflowMode.SEQUENTIAL, WorkflowMode.AUTONOMOUS]),
+  shared: import_zod7.z.boolean(),
+  icon_url: import_zod7.z.string().optional()
 }).readonly();
-var WorkflowUpdateParamsSchema = import_zod6.z.object({
-  project: import_zod6.z.string(),
-  name: import_zod6.z.string(),
-  description: import_zod6.z.string().optional(),
-  yaml_config: import_zod6.z.string(),
-  mode: import_zod6.z.enum([WorkflowMode.SEQUENTIAL, WorkflowMode.AUTONOMOUS]).optional(),
-  shared: import_zod6.z.boolean().optional(),
-  icon_url: import_zod6.z.string().optional()
+var WorkflowUpdateParamsSchema = import_zod7.z.object({
+  project: import_zod7.z.string(),
+  name: import_zod7.z.string(),
+  description: import_zod7.z.string().optional(),
+  yaml_config: import_zod7.z.string(),
+  mode: import_zod7.z.enum([WorkflowMode.SEQUENTIAL, WorkflowMode.AUTONOMOUS]).optional(),
+  shared: import_zod7.z.boolean().optional(),
+  icon_url: import_zod7.z.string().optional()
 }).readonly();
-var WorkflowExecutionListParamsSchema = import_zod6.z.object({
-  page: import_zod6.z.number().prefault(0),
-  per_page: import_zod6.z.number().prefault(10)
+var WorkflowExecutionListParamsSchema = import_zod7.z.object({
+  page: import_zod7.z.number().prefault(0),
+  per_page: import_zod7.z.number().prefault(10)
 }).readonly();
-var WorkflowExecutionCreateParamsSchema = import_zod6.z.object({
-  user_input: import_zod6.z.union([
-    import_zod6.z.string(),
-    import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()),
-    import_zod6.z.array(import_zod6.z.unknown()),
-    import_zod6.z.number(),
-    import_zod6.z.boolean()
+var WorkflowExecutionCreateParamsSchema = import_zod7.z.object({
+  user_input: import_zod7.z.union([
+    import_zod7.z.string(),
+    import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()),
+    import_zod7.z.array(import_zod7.z.unknown()),
+    import_zod7.z.number(),
+    import_zod7.z.boolean()
   ]).optional(),
-  file_name: import_zod6.z.string().optional(),
-  session_id: import_zod6.z.string().optional(),
-  propagate_headers: import_zod6.z.boolean().optional(),
-  tags: import_zod6.z.array(import_zod6.z.string()).optional()
+  file_name: import_zod7.z.string().optional(),
+  session_id: import_zod7.z.string().optional(),
+  propagate_headers: import_zod7.z.boolean().optional(),
+  tags: import_zod7.z.array(import_zod7.z.string()).optional()
 }).readonly();
-var WorkflowExecutionStateListParamsSchema = import_zod6.z.object({
-  page: import_zod6.z.number().prefault(0),
-  per_page: import_zod6.z.number().prefault(10)
+var WorkflowExecutionStateListParamsSchema = import_zod7.z.object({
+  page: import_zod7.z.number().prefault(0),
+  per_page: import_zod7.z.number().prefault(10)
 }).readonly();
 
 // src/services/workflow_execution_state.ts
@@ -1982,6 +2106,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);
@@ -1994,6 +2119,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.
    */
@@ -2123,6 +2254,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);
@@ -2301,6 +2433,8 @@ var BackgroundTaskStatus = {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AnalyticsQueryParamsSchema,
+  AnalyticsService,
   ApiError,
   AssistantChatParamsSchema,
   AssistantCreateParamsSchema,
@@ -2338,11 +2472,13 @@ var BackgroundTaskStatus = {
   LLMProvider,
   LLMService,
   NotFoundError,
+  PaginatedAnalyticsQueryParamsSchema,
   SkillCategory,
   SkillScopeFilter,
   SkillService,
   SkillSortBy,
   SkillVisibility,
+  TIME_PERIOD_VALUES,
   TaskService,
   UserService,
   WorkflowCreateParamsSchema,