@hyperline/cli 0.1.0-build.1.1064600 → 0.1.0-build.1.462ba05

package/dist/bin/hyperline-main.js

@@ -71,6 +71,87 @@ async function clearCredentials() {
   } catch {
   }
 }
+async function resolveCompanyId({ flagCompanyId }) {
+  if (flagCompanyId)
+    return flagCompanyId;
+  const envCompanyId = process.env.HYPERLINE_COMPANY_ID;
+  if (envCompanyId)
+    return envCompanyId;
+  const configFile = await readJsonFile(CONFIG_FILE);
+  return configFile?.companyId;
+}
+async function saveCompanyId({ companyId }) {
+  const existing = await readJsonFile(CONFIG_FILE) ?? {};
+  existing.companyId = companyId;
+  await writeJsonFile(CONFIG_FILE, existing);
+}
+
+// build/prompt.js
+import * as readline from "node:readline";
+function selectPrompt({ message, items }) {
+  if (items.length === 0)
+    return Promise.resolve(void 0);
+  if (items.length === 1)
+    return Promise.resolve(items[0].value);
+  return new Promise((resolve) => {
+    const input = process.stdin;
+    const output = process.stderr;
+    let selectedIndex = 0;
+    const wasRaw = input.isRaw;
+    if (!input.isTTY) {
+      resolve(items[0].value);
+      return;
+    }
+    input.setRawMode(true);
+    readline.emitKeypressEvents(input);
+    function render() {
+      output.write(`\x1B[?25l`);
+      output.write(`\x1B[${items.length}A`);
+      for (const [index, item] of items.entries()) {
+        const isSelected = index === selectedIndex;
+        const pointer = isSelected ? "\x1B[36m>\x1B[0m" : " ";
+        const label = isSelected ? `\x1B[36m${item.label}\x1B[0m` : item.label;
+        const hint = item.hint ? `\x1B[2m ${item.hint}\x1B[0m` : "";
+        output.write(`\x1B[2K${pointer} ${label}${hint}
+`);
+      }
+    }
+    output.write(`${message}
+`);
+    for (const [index, item] of items.entries()) {
+      const isSelected = index === selectedIndex;
+      const pointer = isSelected ? "\x1B[36m>\x1B[0m" : " ";
+      const label = isSelected ? `\x1B[36m${item.label}\x1B[0m` : item.label;
+      const hint = item.hint ? `\x1B[2m ${item.hint}\x1B[0m` : "";
+      output.write(`${pointer} ${label}${hint}
+`);
+    }
+    function cleanup() {
+      input.setRawMode(wasRaw ?? false);
+      input.removeListener("keypress", onKeypress);
+      input.pause();
+      output.write("\x1B[?25h");
+    }
+    function onKeypress(_str, key) {
+      if (!key)
+        return;
+      if (key.name === "up" || key.name === "k" && !key.ctrl) {
+        selectedIndex = selectedIndex <= 0 ? items.length - 1 : selectedIndex - 1;
+        render();
+      } else if (key.name === "down" || key.name === "j" && !key.ctrl) {
+        selectedIndex = selectedIndex >= items.length - 1 ? 0 : selectedIndex + 1;
+        render();
+      } else if (key.name === "return") {
+        cleanup();
+        resolve(items[selectedIndex]?.value);
+      } else if (key.name === "escape" || key.name === "c" && key.ctrl) {
+        cleanup();
+        resolve(void 0);
+      }
+    }
+    input.on("keypress", onKeypress);
+  });
+}
 
 // build/auth.js
 var CLI_CLIENT_NAME = "Hyperline CLI";
@@ -88,7 +169,10 @@ function generateState() {
 async function registerDynamicClient({ baseUrl, redirectUri }) {
   const response = await fetch(`${baseUrl}/oauth/register`, {
     method: "POST",
-    headers: { "Content-Type": "application/json" },
+    headers: {
+      "Content-Type": "application/json",
+      "Hyperline-Source": "cli"
+    },
     body: JSON.stringify({
       client_name: CLI_CLIENT_NAME,
       redirect_uris: [redirectUri],
@@ -106,7 +190,10 @@ async function registerDynamicClient({ baseUrl, redirectUri }) {
 async function exchangeCodeForTokens({ baseUrl, code, clientId, codeVerifier, redirectUri }) {
   const response = await fetch(`${baseUrl}/oauth/tokens`, {
     method: "POST",
-    headers: { "Content-Type": "application/json" },
+    headers: {
+      "Content-Type": "application/json",
+      "Hyperline-Source": "cli"
+    },
     body: JSON.stringify({
       grant_type: "authorization_code",
       code,
@@ -238,11 +325,340 @@ Please open this URL in your browser:
       expiresIn: tokens.expires_in
     });
     process.stdout.write("Login successful!\n");
+    await promptCompanySelection({
+      baseUrl,
+      accessToken: tokens.access_token
+    });
   } catch (error) {
     server.close();
     throw error;
   }
 }
+async function fetchCompanies({ baseUrl, accessToken }) {
+  const response = await fetch(`${baseUrl}/v1/companies`, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Hyperline-Source": "cli"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch companies: ${response.status}`);
+  }
+  const body = await response.json();
+  return body.data;
+}
+async function promptCompanySelection({ baseUrl, accessToken }) {
+  process.stdout.write("\nFetching your companies...\n");
+  const companies = await fetchCompanies({ baseUrl, accessToken });
+  if (companies.length === 0) {
+    process.stdout.write("No companies found for this account.\n");
+    return;
+  }
+  if (companies.length === 1) {
+    const onlyCompany = companies[0];
+    await saveCompanyId({ companyId: onlyCompany.id });
+    process.stdout.write(`Company set to ${onlyCompany.name}
+`);
+    return;
+  }
+  const selectedCompanyId = await selectPrompt({
+    message: "Select a company:",
+    items: companies.map((company) => ({
+      label: company.name,
+      value: company.id,
+      hint: company.id
+    }))
+  });
+  if (!selectedCompanyId) {
+    process.stdout.write("No company selected. You can set one later with: hyperline company select\n");
+    return;
+  }
+  await saveCompanyId({ companyId: selectedCompanyId });
+  const selectedCompany = companies.find((company) => company.id === selectedCompanyId);
+  process.stdout.write(`Company set to ${selectedCompany?.name ?? selectedCompanyId}
+`);
+}
+
+// build/commands/confirm.js
+import * as readline2 from "node:readline";
+function confirmPrompt(message) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+
+// build/commands/events.js
+function resolveIngestBaseUrl(apiBaseUrl) {
+  return apiBaseUrl.replace("api.", "ingest.");
+}
+function registerEventsCommands(parent) {
+  const resource = parent.command("events").description("Manage billable events");
+  resource.command("list").description(`List billable events filtered by event type with optional filters for customer_id, record_id, and timestamp range. Paginated with take/skip.`).requiredOption("--event-type <value>", `Event type to filter by`).option("--take <number>", `take`).option("--skip <number>", `skip`).option("--customer-id <value>", `Filter by customer ID`).option("--record-id-in <value>", `Filter by record ID (comma-separated for multiple)`).option("--timestamp-gte <value>", `Filter events with timestamp >= this ISO8601 date`).option("--timestamp-lte <value>", `Filter events with timestamp <= this ISO8601 date`).option("--order <value>", `Sort order for timestamp`).addHelpText("after", `
+Examples:
+    hyperline events list --event-type api_call
+    hyperline events list --event-type api_call --customer-id cus_xyz789 --take 10`).action(async (opts) => {
+    const ctx = resource.parent?.opts()._ctx;
+    if (!ctx) {
+      process.stderr.write("Error: Not authenticated\n");
+      process.exit(1);
+    }
+    const args = {};
+    if (opts.eventType !== void 0)
+      args.event_type = opts.eventType;
+    if (opts.customerId !== void 0)
+      args.customer_id = opts.customerId;
+    if (opts.recordIdIn !== void 0)
+      args.record_id__in = opts.recordIdIn;
+    if (opts.timestampGte !== void 0)
+      args.timestamp_gte = opts.timestampGte;
+    if (opts.timestampLte !== void 0)
+      args.timestamp_lte = opts.timestampLte;
+    if (opts.order !== void 0)
+      args.order = opts.order;
+    if (opts.take !== void 0)
+      args.take = Number(opts.take);
+    if (opts.skip !== void 0)
+      args.skip = Number(opts.skip);
+    await ctx.execute({
+      method: "GET",
+      path: "/v1/events",
+      args,
+      queryParamKeys: [
+        "event_type",
+        "customer_id",
+        "record_id__in",
+        "timestamp_gte",
+        "timestamp_lte",
+        "order",
+        "take",
+        "skip"
+      ],
+      baseUrlOverride: resolveIngestBaseUrl(ctx.baseUrl)
+    });
+  });
+  resource.command("send").description(`Send a single billable event.`).requiredOption("--customer-id <value>", `Customer ID or external ID`).requiredOption("--event-type <value>", `Event type`).requiredOption("--timestamp <value>", `ISO8601 timestamp`).requiredOption("--record <value>", `Event record as JSON (must include "id" key)`).option("--with-price-calculation", `Whether to calculate prices for the event`).addHelpText("after", `
+Examples:
+    hyperline events send --customer-id cus_xyz --event-type api_call --timestamp 2024-01-15T10:00:00Z --record '{"id":"evt_1","duration":32}'
+    hyperline events send --customer-id cus_xyz --event-type api_call --timestamp 2024-01-15T10:00:00Z --record '{"id":"evt_1"}' --with-price-calculation`).action(async (opts) => {
+    const ctx = resource.parent?.opts()._ctx;
+    if (!ctx) {
+      process.stderr.write("Error: Not authenticated\n");
+      process.exit(1);
+    }
+    let record;
+    try {
+      record = JSON.parse(opts.record);
+    } catch {
+      process.stderr.write(`Error: --record must be valid JSON (e.g. '{"id":"evt_1"}')
+`);
+      process.exit(1);
+    }
+    const body = {
+      customer_id: opts.customerId,
+      event_type: opts.eventType,
+      timestamp: opts.timestamp,
+      record
+    };
+    const args = {};
+    if (opts.withPriceCalculation !== void 0)
+      args.with_price_calculation = true;
+    await ctx.execute({
+      method: "POST",
+      path: "/v1/events",
+      args,
+      queryParamKeys: ["with_price_calculation"],
+      body,
+      baseUrlOverride: resolveIngestBaseUrl(ctx.baseUrl)
+    });
+  });
+  resource.command("send-batch").description(`Send multiple billable events in batch (max 5000 per request). All events must have the same event_type.`).requiredOption("--events <value>", `JSON array of events, each with customer_id, event_type, timestamp, record`).addHelpText("after", `
+Examples:
+    hyperline events send-batch --events '[{"customer_id":"cus_xyz","event_type":"api_call","timestamp":"2024-01-15T10:00:00Z","record":{"id":"evt_1"}},{"customer_id":"cus_xyz","event_type":"api_call","timestamp":"2024-01-15T10:01:00Z","record":{"id":"evt_2"}}]'`).action(async (opts) => {
+    const ctx = resource.parent?.opts()._ctx;
+    if (!ctx) {
+      process.stderr.write("Error: Not authenticated\n");
+      process.exit(1);
+    }
+    let events;
+    try {
+      events = JSON.parse(opts.events);
+    } catch {
+      process.stderr.write("Error: --events must be valid JSON array\n");
+      process.exit(1);
+    }
+    if (!Array.isArray(events)) {
+      process.stderr.write("Error: --events must be a JSON array\n");
+      process.exit(1);
+    }
+    await ctx.execute({
+      method: "POST",
+      path: "/v1/events/batch",
+      args: {},
+      body: events,
+      baseUrlOverride: resolveIngestBaseUrl(ctx.baseUrl)
+    });
+  });
+  resource.command("delete").description(`Delete billable events by record IDs, customer ID, or all events.`).option("--matching <value>", `Matching strategy: record_ids, customer_id, or all`).option("--record-ids <value>", `Comma-separated list of record IDs (when matching=record_ids)`).option("--customer-id <value>", `Customer ID (when matching=customer_id)`).addHelpText("after", `
+Examples:
+    hyperline events delete --matching record_ids --record-ids evt_1,evt_2
+    hyperline events delete --matching customer_id --customer-id cus_xyz
+    hyperline events delete --matching all`).action(async (opts) => {
+    const ctx = resource.parent?.opts()._ctx;
+    if (!ctx) {
+      process.stderr.write("Error: Not authenticated\n");
+      process.exit(1);
+    }
+    const matching = opts.matching;
+    if (!matching || !["record_ids", "customer_id", "all"].includes(matching)) {
+      process.stderr.write("Error: --matching must be one of: record_ids, customer_id, all\n");
+      process.exit(1);
+    }
+    let body;
+    if (matching === "record_ids") {
+      if (!opts.recordIds) {
+        process.stderr.write("Error: --record-ids is required when matching=record_ids\n");
+        process.exit(1);
+      }
+      body = {
+        matching: "record_ids",
+        record_ids: opts.recordIds.split(",")
+      };
+    } else if (matching === "customer_id") {
+      if (!opts.customerId) {
+        process.stderr.write("Error: --customer-id is required when matching=customer_id\n");
+        process.exit(1);
+      }
+      body = { matching: "customer_id", customer_id: opts.customerId };
+    } else {
+      const confirmed = await confirmPrompt("Are you sure you want to delete ALL events? (y/N) ");
+      if (!confirmed) {
+        process.stdout.write("Aborted.\n");
+        return;
+      }
+      body = { matching: "all" };
+    }
+    await ctx.execute({
+      method: "DELETE",
+      path: "/v1/events",
+      args: {},
+      body,
+      baseUrlOverride: resolveIngestBaseUrl(ctx.baseUrl)
+    });
+  });
+  resource.command("calculate-prices").description(`Ingest a billable event and calculate its prices. After first ingestion, returns cached prices.`).requiredOption("--customer-id <value>", `Customer ID or external ID`).requiredOption("--event-type <value>", `Event type`).requiredOption("--timestamp <value>", `ISO8601 timestamp`).requiredOption("--record <value>", `Event record as JSON (must include "id" key)`).option("--product-id <value>", `Hyperline product ID`).option("--subscription-id <value>", `Hyperline subscription ID`).option("--include-tax", `Include amounts with tax`).addHelpText("after", `
+Examples:
+    hyperline events calculate-prices --customer-id cus_xyz --event-type api_call --timestamp 2024-01-15T10:00:00Z --record '{"id":"evt_1"}'
+    hyperline events calculate-prices --customer-id cus_xyz --event-type api_call --timestamp 2024-01-15T10:00:00Z --record '{"id":"evt_1"}' --product-id itm_abc --include-tax`).action(async (opts) => {
+    const ctx = resource.parent?.opts()._ctx;
+    if (!ctx) {
+      process.stderr.write("Error: Not authenticated\n");
+      process.exit(1);
+    }
+    let record;
+    try {
+      record = JSON.parse(opts.record);
+    } catch {
+      process.stderr.write(`Error: --record must be valid JSON (e.g. '{"id":"evt_1"}')
+`);
+      process.exit(1);
+    }
+    const body = {
+      customer_id: opts.customerId,
+      event_type: opts.eventType,
+      timestamp: opts.timestamp,
+      record
+    };
+    const args = {};
+    if (opts.productId !== void 0)
+      args.product_id = opts.productId;
+    if (opts.subscriptionId !== void 0)
+      args.subscription_id = opts.subscriptionId;
+    if (opts.includeTax !== void 0)
+      args.include_tax = true;
+    await ctx.execute({
+      method: "POST",
+      path: "/v1/events/prices",
+      args,
+      queryParamKeys: ["product_id", "subscription_id", "include_tax"],
+      body,
+      baseUrlOverride: resolveIngestBaseUrl(ctx.baseUrl)
+    });
+  });
+  resource.command("simulate-prices").description(`Simulate prices for a billable event without ingesting it.`).requiredOption("--event-type <value>", `Event type`).requiredOption("--record <value>", `Event record as JSON (must include "id" key)`).option("--customer-id <value>", `Customer ID or external ID`).option("--timestamp <value>", `ISO8601 timestamp`).option("--product-id <value>", `Hyperline product ID`).option("--subscription-id <value>", `Hyperline subscription ID`).option("--include-tax", `Include amounts with tax`).addHelpText("after", `
+Examples:
+    hyperline events simulate-prices --event-type api_call --record '{"id":"evt_1","duration":32}'
+    hyperline events simulate-prices --event-type api_call --record '{"id":"evt_1"}' --product-id itm_abc --include-tax`).action(async (opts) => {
+    const ctx = resource.parent?.opts()._ctx;
+    if (!ctx) {
+      process.stderr.write("Error: Not authenticated\n");
+      process.exit(1);
+    }
+    let record;
+    try {
+      record = JSON.parse(opts.record);
+    } catch {
+      process.stderr.write(`Error: --record must be valid JSON (e.g. '{"id":"evt_1"}')
+`);
+      process.exit(1);
+    }
+    const body = {
+      event_type: opts.eventType,
+      record
+    };
+    if (opts.customerId !== void 0)
+      body.customer_id = opts.customerId;
+    if (opts.timestamp !== void 0)
+      body.timestamp = opts.timestamp;
+    const args = {};
+    if (opts.productId !== void 0)
+      args.product_id = opts.productId;
+    if (opts.subscriptionId !== void 0)
+      args.subscription_id = opts.subscriptionId;
+    if (opts.includeTax !== void 0)
+      args.include_tax = true;
+    await ctx.execute({
+      method: "POST",
+      path: "/v1/events/simulate-prices",
+      args,
+      queryParamKeys: ["product_id", "subscription_id", "include_tax"],
+      body,
+      baseUrlOverride: resolveIngestBaseUrl(ctx.baseUrl)
+    });
+  });
+  resource.command("get-prices").description(`Get previous price calculation results by calculation ID or record ID.`).option("--record-id <value>", `Record ID to look up`).option("--calculation-id <value>", `Calculation ID to look up`).addHelpText("after", `
+Examples:
+    hyperline events get-prices --record-id D32NAA8
+    hyperline events get-prices --calculation-id cal_1234567890`).action(async (opts) => {
+    const ctx = resource.parent?.opts()._ctx;
+    if (!ctx) {
+      process.stderr.write("Error: Not authenticated\n");
+      process.exit(1);
+    }
+    if (!opts.recordId && !opts.calculationId) {
+      process.stderr.write("Error: at least one of --record-id or --calculation-id is required\n");
+      process.exit(1);
+    }
+    const args = {};
+    if (opts.recordId !== void 0)
+      args.record_id = opts.recordId;
+    if (opts.calculationId !== void 0)
+      args.calculation_id = opts.calculationId;
+    await ctx.execute({
+      method: "GET",
+      path: "/v1/events/prices",
+      args,
+      queryParamKeys: ["record_id", "calculation_id"],
+      baseUrlOverride: resolveIngestBaseUrl(ctx.baseUrl)
+    });
+  });
+}
 
 // build/commands/generated/analytics.js
 function registerAnalyticsCommands(parent) {
@@ -354,21 +770,6 @@ Examples:
   });
 }
 
-// build/commands/confirm.js
-import * as readline from "node:readline";
-function confirmPrompt(message) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stderr
-  });
-  return new Promise((resolve) => {
-    rl.question(message, (answer) => {
-      rl.close();
-      resolve(answer.toLowerCase() === "y");
-    });
-  });
-}
-
 // build/commands/generated/coupons.js
 function registerCouponsCommands(parent) {
   const resource = parent.command("coupons").description("Manage coupons");
@@ -7726,8 +8127,364 @@ var countriesAndCurrencies = (
   ]
 );
 
+// ../hyperline-monitoring/build/context/context.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var executionContextStorage = new AsyncLocalStorage();
+function getExecutionContext() {
+  return executionContextStorage.getStore();
+}
+
+// ../hyperline-monitoring/build/context/correlationId.js
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var correlationIdStorage = new AsyncLocalStorage2();
+function getCorrelationId() {
+  return correlationIdStorage.getStore();
+}
+
+// ../hyperline-config/build/index.js
+import "dotenv/config";
+import * as stackTraceParser from "stacktrace-parser";
+import { ZodOptional as ZodOptional2, z as z2 } from "zod";
+function coerceBoolean() {
+  return z2.any().refine((value) => ["true", "false"].includes(value), {
+    message: "Expected boolean"
+  }).transform((value) => (
+    // biome-ignore lint/complexity/noUselessTernary: ignore
+    value === "true" ? true : false
+  ));
+}
+var types = {
+  string: z2.coerce.string,
+  number: z2.coerce.number,
+  boolean: coerceBoolean,
+  enum: z2.enum
+};
+function getConfig(schema, testValues) {
+  const validator = z2.object(Object.fromEntries(Object.entries(schema).map(([key, zodType]) => {
+    if (zodType instanceof ZodOptional2) {
+      return [key, z2.string().optional()];
+    }
+    return [key, z2.string()];
+  })));
+  const processEnv = process.env;
+  const isTestMode = processEnv.NODE_ENV === "test";
+  const envVariables = {
+    ...processEnv,
+    ...isTestMode && testValues ? Object.fromEntries(Object.entries(testValues).map(([key, value]) => [key, String(value)])) : {}
+  };
+  const packageName = envVariables.npm_package_name;
+  const parseProcessEnvResult = validator.safeParse(envVariables);
+  if (!parseProcessEnvResult.success) {
+    const parsedStackTrace = stackTraceParser.parse(parseProcessEnvResult.error.stack ?? "");
+    const getConfigCallLine = parsedStackTrace.find((line) => {
+      return !line.file?.includes("hyperline-config") && (line.file?.includes("apps/") || line.file?.includes("core/") || line.file?.includes("packages/"));
+    });
+    const callerFile = getConfigCallLine?.file;
+    console.error(`Invalid environment variables for service \`${packageName}\`: \`${callerFile}\``);
+    console.error(parseProcessEnvResult.error.format());
+    process.exit(1);
+  }
+  const coercion = z2.object(schema);
+  return coercion.parse(parseProcessEnvResult.data);
+}
+
+// ../hyperline-monitoring/build/config.js
+var config = getConfig({
+  // config
+  APP_VERSION: types.string().optional(),
+  LOGGER_CONSOLE_ENABLED: types.boolean().optional(),
+  LOGGER_STDOUT_ENABLED: types.boolean().optional(),
+  NODE_ENV: types.enum(["local", "test", "staging", "sandbox", "production"]),
+  EVENT_LOOP_MONITORING_ENABLED: types.boolean().optional(),
+  MEMORY_MONITORING_ENABLED: types.boolean().optional()
+  // secrets
+}, {
+  APP_VERSION: void 0,
+  LOGGER_CONSOLE_ENABLED: false,
+  LOGGER_STDOUT_ENABLED: false,
+  EVENT_LOOP_MONITORING_ENABLED: false,
+  MEMORY_MONITORING_ENABLED: false,
+  NODE_ENV: "test"
+});
+
+// ../hyperline-monitoring/build/logger/logger.js
+import * as util from "node:util";
+import prune2 from "json-prune";
+import * as winston from "winston";
+
+// ../hyperline-monitoring/build/logger/formatting/format.js
+import prune from "json-prune";
+function jsonFormat(info) {
+  const prunedInfo = JSON.parse(prune(info));
+  for (const [key, value] of Object.entries(prunedInfo)) {
+    info[key] = value;
+  }
+  return info;
+}
+function addMetadata({ getCorrelationId: getCorrelationId2, getExecutionContext: getExecutionContext2 }) {
+  return (info) => {
+    const correlationId = getCorrelationId2();
+    const executionContext = getExecutionContext2();
+    let traceContext;
+    return {
+      ...info,
+      ...executionContext ?? {},
+      ...traceContext ?? {},
+      correlationId
+    };
+  };
+}
+function transformErrorEnrich(info, { depth }) {
+  if (depth <= 0) {
+    return info;
+  }
+  Object.entries(info).forEach(([key, value]) => {
+    let newValue = value;
+    if (newValue instanceof Error) {
+      newValue = {
+        ...newValue,
+        // Copy error properties manually because they're not enumerable
+        level: newValue.level,
+        stack: newValue.stack,
+        message: newValue.message,
+        name: newValue.name
+      };
+    }
+    if (newValue instanceof Object) {
+      newValue = transformErrorEnrich(newValue, { depth: depth - 1 });
+    }
+    const isPropertyWritable = Object.getOwnPropertyDescriptor(info, key)?.writable ?? true;
+    if (isPropertyWritable && newValue !== value) {
+      info[key] = newValue;
+    }
+  });
+  return info;
+}
+function transformPrune(info) {
+  Object.entries(info).forEach(([key, value]) => {
+    if (typeof value === "function") {
+      return;
+    }
+    const newValue = value instanceof Object ? JSON.parse(prune(value, { depthDecr: 6 })) : value;
+    const isPropertyWritable = Object.getOwnPropertyDescriptor(info, key)?.writable ?? true;
+    if (isPropertyWritable && newValue !== value) {
+      info[key] = newValue;
+    }
+  });
+  return info;
+}
+function transformAxiosError(info) {
+  Object.entries(info).forEach(([key, value]) => {
+    if (typeof value === "object" && value?.name === "AxiosError") {
+      info[key] = formatAxiosError(value);
+    }
+  });
+  return info;
+}
+function formatAxiosError(error) {
+  if (!isRecord(error) || error.name !== "AxiosError") {
+    return error;
+  }
+  const request = isRecord(error.config) ? error.config : void 0;
+  const response = isRecord(error.response) ? error.response : void 0;
+  return {
+    name: error.name,
+    message: error.message,
+    code: error.code,
+    request: {
+      method: request?.method,
+      url: request?.url,
+      baseURL: request?.baseURL,
+      params: request?.params,
+      headers: request?.headers,
+      "axios-retry": request?.["axios-retry"]
+    },
+    response: {
+      status: response?.status,
+      statusText: response?.statusText,
+      headers: response?.headers,
+      data: response?.data
+    }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../hyperline-monitoring/build/logger/formatting/routePath.js
+function transformUrlIntoRoutePath({ params, originalUrl }) {
+  let routePath = originalUrl;
+  for (const [param, value] of Object.entries(params ?? {})) {
+    const strValue = Array.isArray(value) ? value.join("/") : value;
+    routePath = routePath.replace(strValue, `:${param}`);
+  }
+  return routePath.split("?")[0] ?? routePath;
+}
+
+// ../hyperline-monitoring/build/logger/formatting/http.js
+function logHttpRequest(logger2, request, extra) {
+  const { message, metadata } = transform(request);
+  logger2.info(`HTTP REQ - ${message} ${extra?.postfix || ""}`, {
+    ...metadata,
+    ...extra?.metadata ?? {}
+  });
+}
+function logHttpResponse(logger2, response, responseTime, extra) {
+  const { request, statusCode, responseBody } = response;
+  const { message, metadata } = transform(request);
+  const readableResponseTime = responseTime ? getReadableTime(responseTime) : void 0;
+  const responseMetadata = {
+    statusCode,
+    responseTime,
+    responseBody
+  };
+  logger2.info(`HTTP RES - ${message} ${statusCode} ${readableResponseTime || ""} ${extra?.postfix || ""}`, {
+    ...metadata,
+    ...responseMetadata,
+    ...extra?.metadata ?? {}
+  });
+}
+function transform(request) {
+  const method = request.method.toUpperCase();
+  const message = `${method} ${request.originalUrl}`;
+  const metadata = {};
+  metadata.method = method;
+  metadata.url = request.url;
+  metadata.path = request.path;
+  metadata.hostname = request.hostname;
+  metadata.originalUrl = request.originalUrl;
+  metadata.requestBody = request.body;
+  metadata.routePath = transformUrlIntoRoutePath(request);
+  metadata.apiKeyEnd = request.headers["authorization"]?.slice(-6);
+  return { message, metadata };
+}
+function getReadableTime(time) {
+  return time < 1e4 ? `${time}ms` : `${Math.round(time / 1e3)}s`;
+}
+
+// ../hyperline-monitoring/build/logger/utils/network.js
+import * as os2 from "node:os";
+function getIpAddress() {
+  const interfaces = Object.values(os2.networkInterfaces()).flat().filter((networkInterface) => {
+    return networkInterface !== void 0;
+  });
+  const mainInterface = interfaces.find(({ family, internal }) => family === "IPv4" && internal === false);
+  return mainInterface ? mainInterface.address : null;
+}
+
+// ../hyperline-monitoring/build/logger/logger.js
+function buildLoggerFactory({ config: config2, context }) {
+  const defaultMeta = {
+    env: context.env,
+    service: context.service,
+    version: context.version,
+    pid: process.pid,
+    ppid: process.ppid,
+    host: getIpAddress()
+  };
+  const transports2 = [];
+  if (config2.enableConsoleTransport) {
+    transports2.push(createTransportConsole());
+  }
+  if (config2.enableStdoutTransport) {
+    transports2.push(createTransportStdout());
+  }
+  if (Object.values(config2).every((value) => !value)) {
+    transports2.push(createTransportSilent());
+  }
+  for (const transport of transports2) {
+    transport.on("error", (error) => {
+      console.error(`Unable to log to transport=${transport.name}: ${error.message} ${JSON.stringify(error)}`);
+    });
+  }
+  const internalLogger = winston.createLogger({
+    transports: transports2,
+    defaultMeta,
+    format: winston.format.combine(winston.format.splat(), winston.format(addMetadata({ getCorrelationId, getExecutionContext }))(), winston.format(transformErrorEnrich)({ depth: 5 }), winston.format(transformPrune)(), winston.format(transformAxiosError)(), winston.format.timestamp()),
+    exitOnError: false
+  });
+  function createLogger3({ serviceName }) {
+    const logger2 = internalLogger.child({ subService: serviceName });
+    return {
+      debug: bindLogger(logger2, "debug"),
+      info: bindLogger(logger2, "info"),
+      warn: bindLogger(logger2, "warn"),
+      error: bindLogger(logger2, "error"),
+      on: logger2.on.bind(logger2),
+      end: logger2.end.bind(logger2)
+    };
+  }
+  return {
+    createLogger: createLogger3
+  };
+}
+function bindLogger(logger2, severity) {
+  return (message, data) => {
+    logger2[severity].bind(logger2)(message, preserveReservedKeys(data));
+  };
+}
+function preserveReservedKeys(data) {
+  if (!data)
+    return;
+  return Object.fromEntries(Object.entries(data).map(([key, value]) => {
+    let finalKey = key;
+    if (key === "status") {
+      finalKey = "_status";
+    } else if (key === "service") {
+      finalKey = "_service";
+    }
+    return [finalKey, value];
+  }));
+}
+var verboseLevels = ["warn", "error", "debug"];
+function createTransportConsole() {
+  return new winston.transports.Console({
+    level: "debug",
+    handleExceptions: true,
+    format: winston.format.combine(winston.format(jsonFormat)(), winston.format((info) => {
+      const { level, message, ...others } = info;
+      const parts = [message];
+      if (Object.keys(others).length > 0 && verboseLevels.includes(level)) {
+        const rawOthers = JSON.parse(prune2(others));
+        parts.push(util.inspect(rawOthers, false, 4, true));
+      }
+      info.message = parts.filter((part) => !!part).join("\n");
+      return info;
+    })(), winston.format.colorize(), winston.format.printf(({ timestamp, level, message, service = "?" }) => {
+      const result = `[${timestamp}] ${level} ${service}: ${message}`;
+      return result.replace(/\\n/g, "\n");
+    }))
+  });
+}
+function createTransportStdout() {
+  return new winston.transports.Console({
+    level: "debug",
+    handleExceptions: true,
+    format: winston.format.combine(winston.format(jsonFormat)(), winston.format.timestamp(), winston.format.json())
+  });
+}
+function createTransportSilent() {
+  return new winston.transports.Console({
+    silent: true
+  });
+}
+
+// ../hyperline-monitoring/build/logger/instance.js
+var loggerFactory = buildLoggerFactory({
+  config: {
+    enableConsoleTransport: config.LOGGER_CONSOLE_ENABLED ?? false,
+    enableStdoutTransport: config.LOGGER_STDOUT_ENABLED ?? false
+  },
+  context: {
+    env: config.NODE_ENV,
+    service: "api",
+    version: config.APP_VERSION
+  }
+});
+var createLogger2 = loggerFactory.createLogger;
+var logger = loggerFactory.createLogger({ serviceName: "default" });
+
 // ../hyperline-lib/build/utils/config/usStates.js
-import { logger } from "@hyperline/monitoring";
 var usStates = [
   "AA",
   "AE",
@@ -7792,7 +8549,7 @@ var usStates = [
 
 // ../hyperline-lib/build/utils/dates.js
 import { toLocalTime, toUtc } from "@hyperline/shared";
-import { add, addDays, addHours, addMinutes, addMonths, addWeeks, addYears, areIntervalsOverlapping, differenceInCalendarDays, differenceInCalendarYears, differenceInMilliseconds, differenceInMonths, differenceInWeeks, eachDayOfInterval, endOfDay, endOfMonth, endOfQuarter, endOfWeek, endOfYear, format, getHours, getISOWeek, getISOWeekYear, getMilliseconds, getMinutes, getSeconds, isBefore, isEqual, isSameDay, parse, setHours, setMilliseconds, setMinutes, setSeconds, startOfDay, startOfMonth, startOfQuarter, startOfWeek, startOfYear, sub } from "date-fns";
+import { add, addDays, addHours, addMinutes, addMonths, addWeeks, addYears, areIntervalsOverlapping, differenceInCalendarDays, differenceInCalendarYears, differenceInMilliseconds, differenceInMonths, differenceInWeeks, eachDayOfInterval, endOfDay, endOfMonth, endOfQuarter, endOfWeek, endOfYear, format as format2, getHours, getISOWeek, getISOWeekYear, getMilliseconds, getMinutes, getSeconds, isBefore, isEqual, isSameDay, parse as parse2, setHours, setMilliseconds, setMinutes, setSeconds, startOfDay, startOfMonth, startOfQuarter, startOfWeek, startOfYear, sub } from "date-fns";
 
 // ../hyperline-lib/build/utils/document.js
 import { toLocalTime as toLocalTime2 } from "@hyperline/shared";
@@ -7864,15 +8621,15 @@ var ErrorSchema = z.object({
 });
 
 // ../hyperline-lib/build/http/dto/pagination.js
-import z2 from "zod";
+import z3 from "zod";
 var PublicPaginationParams = {
-  take: z2.coerce.number().nonnegative().max(100).optional().default(50),
-  skip: z2.coerce.number().nonnegative().optional().default(0)
+  take: z3.coerce.number().nonnegative().max(100).optional().default(50),
+  skip: z3.coerce.number().nonnegative().optional().default(0)
 };
-var PublicPaginationSchema = z2.object(PublicPaginationParams);
+var PublicPaginationSchema = z3.object(PublicPaginationParams);
 
 // ../hyperline-lib/build/http/dto/sort.js
-import z3 from "zod";
+import z4 from "zod";
 
 // ../hyperline-lib/build/http/dto/state.js
 var StateSchema = z.enum(usStates).openapi({
@@ -7886,12 +8643,356 @@ import { ZodError as ZodError2 } from "zod";
 // ../hyperline-lib/build/http/helpers/correlation.js
 import { validate as validateUuid } from "uuid";
 
+// ../hyperline-i18n/build/language.js
+import * as i18next from "i18next";
+import { z as z5 } from "zod";
+
+// ../hyperline-i18n/build/config/languages.js
+var languages = [
+  { id: "fr", name: "French", isoCode: "fr", locale: "fr-FR" },
+  { id: "en", name: "English", isoCode: "en", locale: "en-US" },
+  { id: "de", name: "German", isoCode: "de", locale: "de-DE" },
+  { id: "it", name: "Italian", isoCode: "it", locale: "it-IT" },
+  { id: "nl", name: "Dutch", isoCode: "nl", locale: "nl-NL" },
+  { id: "es", name: "Spanish", isoCode: "es", locale: "es-ES" },
+  { id: "pt", name: "Portuguese", isoCode: "pt", locale: "pt-PT" },
+  { id: "pl", name: "Polish", isoCode: "pl", locale: "pl-PL" }
+];
+
+// ../hyperline-i18n/build/locales/de.js
+var de = {
+  "accounting.revrec.creditLineDescription": "Umsatz realisieren \u2013 Zeitplan {{scheduleId}}, Zeitraum {{periodDate}}",
+  "accounting.revrec.debitLineDescription": "Abgrenzungsposten reduzieren \u2013 Zeitplan {{scheduleId}}, Zeitraum {{periodDate}}",
+  "accounting.revrec.discountCreditLineDescription": "Erl\xF6sminderung (Rabatt) erfassen \u2013 Zeitplan {{scheduleId}}, Zeitraum {{periodDate}}",
+  "accounting.revrec.discountDebitLineDescription": "Abgegrenzten Rabatt reduzieren \u2013 Zeitplan {{scheduleId}}, Zeitraum {{periodDate}}",
+  "accounting.revrec.entryDescription": "Umsatzrealisierung f\xFCr Zeitplan {{scheduleId}}, Zeitraum {{periodStart}} - {{periodEnd}}",
+  "creditNotes.refundChargeName": "R\xFCckerstattung f\xFCr die Rechnung",
+  "credits.bundleOf": "{{productName}} - Paket mit {{creditCount}} Guthaben",
+  "credits.unitsOf": "{{productName}} - {{creditCount}} Guthaben",
+  "einvoicing.paymentFromWallet": "Zahlung aus Guthaben",
+  "einvoicing.paymentProcessed": "Zahlung verarbeitet",
+  "einvoicing.paymentReceived": "Zahlung erhalten",
+  "invoices.outstandingProduct.description": "Unbezahlter Betrag der Rechnung{{invoiceNumber}} vom {{date}}",
+  "invoices.outstandingProduct.descriptionPeriod": "Unbezahlter Betrag der Rechnung{{invoiceNumber}} vom {{periodStart}} bis {{periodEnd}}",
+  "invoices.outstandingProduct.name": "Offener Saldo",
+  "invoices.prorata.paymentForItem": "Anteilig berechneter Betrag f\xFCr",
+  "invoices.prorata.refundForItem": "Anteilig erstatteter Betrag f\xFCr",
+  "subscriptions.closingChargeName": "Abschlussgeb\xFChr f\xFCr das Abonnement",
+  "subscriptions.correction": "Vorperiodische Anpassung",
+  "subscriptions.updates.addCoupon": "Gutschein hinzuf\xFCgen {{couponName}}",
+  "subscriptions.updates.addProduct": "{{productName}} hinzuf\xFCgen",
+  "subscriptions.updates.removeCoupon": "Gutschein entfernen {{couponName}}",
+  "subscriptions.updates.removeProduct": "{{productName}} entfernen",
+  "subscriptions.updates.unit": "Einheiten",
+  "subscriptions.updates.updateCount": "Aktualisieren Sie {{productName}} ({{previousCount}} \u2192 {{newCount}} {{unit}})",
+  "subscriptions.updates.updateCount.description.full.committed.invoiced": "Eine minimale zugesicherte Anzahl von {{committedCount}} wurde f\xFCr den gesamten Zeitraum angewendet.",
+  "subscriptions.updates.updateCount.description.full.committed.not_invoiced": "Betrag von {{amount}} (mit einer minimal zugesicherten Anzahl von {{committedCount}}) f\xFCr den gesamten Zeitraum nicht in Rechnung gestellt",
+  "subscriptions.updates.updateCount.description.full.not_committed.invoiced": "Diese Position wurde f\xFCr den gesamten Zeitraum in Rechnung gestellt",
+  "subscriptions.updates.updateCount.description.full.not_committed.not_invoiced": "Betrag von {{amount}} f\xFCr den gesamten Zeitraum nicht in Rechnung gestellt",
+  "subscriptions.updates.updateCount.description.prorata.committed.invoiced": "Eine minimale zugesicherte Anzahl von {{committedCount}} wurde angewendet.",
+  "subscriptions.updates.updateCount.description.prorata.committed.not_invoiced": "Betrag von {{amount}} (mit einer minimal zugesicherten Anzahl von {{committedCount}}) f\xFCr den anteiligen Zeitraum nicht in Rechnung gestellt",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.invoiced": "Diese Position wurde f\xFCr den anteiligen Zeitraum in Rechnung gestellt",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.not_invoiced": "Betrag von {{amount}} f\xFCr den anteiligen Zeitraum nicht in Rechnung gestellt",
+  "subscriptions.updates.updatePrices": "Preise f\xFCr {{productName}} aktualisieren"
+};
+
+// ../hyperline-i18n/build/locales/en.js
+var en = {
+  "creditNotes.refundChargeName": "Refund for invoice",
+  "credits.bundleOf": "{{productName}} - Pack of {{creditCount}} credits",
+  "credits.unitsOf": "{{productName}} - {{creditCount}} credits",
+  "invoices.outstandingProduct.description": "Unpaid amount from the invoice{{invoiceNumber}} emitted on {{date}}",
+  "invoices.outstandingProduct.descriptionPeriod": "Unpaid amount from the invoice{{invoiceNumber}} from {{periodStart}} to {{periodEnd}}",
+  "invoices.outstandingProduct.name": "Outstanding balance",
+  "invoices.prorata.paymentForItem": "Prorated payment for",
+  "invoices.prorata.refundForItem": "Prorated refund for",
+  "subscriptions.closingChargeName": "Closing fee for subscription",
+  "subscriptions.correction": "Adjustment previous period",
+  "subscriptions.updates.addCoupon": "Add coupon {{couponName}}",
+  "subscriptions.updates.addProduct": "Add {{productName}}",
+  "subscriptions.updates.removeCoupon": "Remove coupon {{couponName}}",
+  "subscriptions.updates.removeProduct": "Remove {{productName}}",
+  "subscriptions.updates.unit": "units",
+  "subscriptions.updates.updatePrices": "Update prices for {{productName}}",
+  "subscriptions.updates.updateCount": "Update {{productName}} count ({{previousCount}} \u2192 {{newCount}} {{unit}})",
+  "subscriptions.updates.updateCount.description.prorata.committed.invoiced": "A minimum committed count of {{committedCount}} has been applied.",
+  "subscriptions.updates.updateCount.description.prorata.committed.not_invoiced": "Amount of {{amount}} (with a minimum committed count of {{committedCount}}) not invoiced for the prorated period",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.invoiced": "This line has been invoiced for the prorated period",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.not_invoiced": "Amount of {{amount}} not invoiced for the prorated period",
+  "subscriptions.updates.updateCount.description.full.committed.invoiced": "A minimum committed count of {{committedCount}} has been applied for the full period.",
+  "subscriptions.updates.updateCount.description.full.committed.not_invoiced": "Amount of {{amount}} (with a minimum committed count of {{committedCount}}) not invoiced for the full period",
+  "subscriptions.updates.updateCount.description.full.not_committed.invoiced": "This line has been invoiced for the full period",
+  "subscriptions.updates.updateCount.description.full.not_committed.not_invoiced": "Amount of {{amount}} not invoiced for the full period",
+  "accounting.revrec.entryDescription": "Revenue recognition for schedule {{scheduleId}}, period {{periodStart}} - {{periodEnd}}",
+  "accounting.revrec.debitLineDescription": "Decrease deferred revenue \u2013 schedule {{scheduleId}}, period {{periodDate}}",
+  "accounting.revrec.creditLineDescription": "Recognize revenue \u2013 schedule {{scheduleId}}, period {{periodDate}}",
+  "accounting.revrec.discountDebitLineDescription": "Decrease deferred discount \u2013 schedule {{scheduleId}}, period {{periodDate}}",
+  "accounting.revrec.discountCreditLineDescription": "Recognize contra-revenue (discount) \u2013 schedule {{scheduleId}}, period {{periodDate}}",
+  "einvoicing.paymentProcessed": "Payment processed",
+  "einvoicing.paymentReceived": "Payment received",
+  "einvoicing.paymentFromWallet": "Payment from wallet"
+};
+
+// ../hyperline-i18n/build/locales/es.js
+var es = {
+  "accounting.revrec.creditLineDescription": "Reconocer ingresos \u2013 cronograma {{scheduleId}}, per\xEDodo {{periodDate}}",
+  "accounting.revrec.debitLineDescription": "Disminuci\xF3n de ingresos diferidos \u2013 cronograma {{scheduleId}}, per\xEDodo {{periodDate}}",
+  "accounting.revrec.discountCreditLineDescription": "Reconocer contra-ingresos (descuento) \u2013 cronograma {{scheduleId}}, per\xEDodo {{periodDate}}",
+  "accounting.revrec.discountDebitLineDescription": "Disminuci\xF3n de descuento diferido \u2013 cronograma {{scheduleId}}, per\xEDodo {{periodDate}}",
+  "accounting.revrec.entryDescription": "Reconocimiento de ingresos para el cronograma {{scheduleId}}, per\xEDodo {{periodStart}} - {{periodEnd}}",
+  "creditNotes.refundChargeName": "Reembolso por factura",
+  "credits.bundleOf": "{{productName}} - Paquete de {{creditCount}} cr\xE9ditos",
+  "credits.unitsOf": "{{productName}} - {{creditCount}} cr\xE9ditos",
+  "einvoicing.paymentFromWallet": "Pago desde el monedero",
+  "einvoicing.paymentProcessed": "Pago procesado",
+  "einvoicing.paymentReceived": "Pago recibido",
+  "invoices.outstandingProduct.description": "Monto pendiente de la factura{{invoiceNumber}} emitida el {{date}}",
+  "invoices.outstandingProduct.descriptionPeriod": "Monto pendiente de la factura{{invoiceNumber}} del {{periodStart}} al {{periodEnd}}",
+  "invoices.outstandingProduct.name": "Saldo pendiente",
+  "invoices.prorata.paymentForItem": "Pago prorrateado por",
+  "invoices.prorata.refundForItem": "Reembolso prorrateado por",
+  "subscriptions.closingChargeName": "Cargo por cierre de suscripci\xF3n",
+  "subscriptions.correction": "Ajuste del periodo anterior",
+  "subscriptions.updates.addCoupon": "A\xF1adir cup\xF3n {{couponName}}",
+  "subscriptions.updates.addProduct": "A\xF1adir {{productName}}",
+  "subscriptions.updates.removeCoupon": "Eliminar cup\xF3n {{couponName}}",
+  "subscriptions.updates.removeProduct": "Eliminar {{productName}}",
+  "subscriptions.updates.unit": "unidades",
+  "subscriptions.updates.updateCount": "Actualizar {{productName}} ({{previousCount}} \u2192 {{newCount}} {{unit}})",
+  "subscriptions.updates.updateCount.description.full.committed.invoiced": "Se ha aplicado un m\xEDnimo comprometido de {{committedCount}} para el per\xEDodo completo.",
+  "subscriptions.updates.updateCount.description.full.committed.not_invoiced": "Importe de {{amount}} (con un m\xEDnimo comprometido de {{committedCount}}) no facturado para el per\xEDodo completo",
+  "subscriptions.updates.updateCount.description.full.not_committed.invoiced": "Esta l\xEDnea ha sido facturada para el per\xEDodo completo",
+  "subscriptions.updates.updateCount.description.full.not_committed.not_invoiced": "Importe de {{amount}} no facturado para el per\xEDodo completo",
+  "subscriptions.updates.updateCount.description.prorata.committed.invoiced": "Se ha aplicado un m\xEDnimo comprometido de {{committedCount}}.",
+  "subscriptions.updates.updateCount.description.prorata.committed.not_invoiced": "Importe de {{amount}} (con un m\xEDnimo comprometido de {{committedCount}}) no facturado para el per\xEDodo prorrateado",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.invoiced": "Esta l\xEDnea ha sido facturada para el per\xEDodo prorrateado",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.not_invoiced": "Importe de {{amount}} no facturado para el per\xEDodo prorrateado",
+  "subscriptions.updates.updatePrices": "Actualizar precios para {{productName}}"
+};
+
+// ../hyperline-i18n/build/locales/fr.js
+var fr = {
+  "accounting.revrec.creditLineDescription": "Reconnaissance du chiffre d'affaires \u2013 \xE9ch\xE9ancier {{scheduleId}}, p\xE9riode {{periodDate}}",
+  "accounting.revrec.debitLineDescription": "Diminution des produits constat\xE9s d'avance \u2013 \xE9ch\xE9ancier {{scheduleId}}, p\xE9riode {{periodDate}}",
+  "accounting.revrec.discountCreditLineDescription": "Reconnaissance du contre-revenu (remise) \u2013 \xE9ch\xE9ancier {{scheduleId}}, p\xE9riode {{periodDate}}",
+  "accounting.revrec.discountDebitLineDescription": "Diminution des remises diff\xE9r\xE9es \u2013 \xE9ch\xE9ancier {{scheduleId}}, p\xE9riode {{periodDate}}",
+  "accounting.revrec.entryDescription": "Reconnaissance du chiffre d'affaires pour l'\xE9ch\xE9ancier {{scheduleId}}, p\xE9riode {{periodStart}} - {{periodEnd}}",
+  "creditNotes.refundChargeName": "Remboursement pour facture",
+  "credits.bundleOf": "{{productName}} - Pack de {{creditCount}} cr\xE9dits",
+  "credits.unitsOf": "{{productName}} - {{creditCount}} cr\xE9dits",
+  "einvoicing.paymentFromWallet": "Paiement depuis le portefeuille",
+  "einvoicing.paymentProcessed": "Paiement effectu\xE9",
+  "einvoicing.paymentReceived": "Paiement re\xE7u",
+  "invoices.outstandingProduct.description": "Montant impay\xE9 de la facture{{invoiceNumber}} \xE9mise le {{date}}",
+  "invoices.outstandingProduct.descriptionPeriod": "Montant impay\xE9 de la facture{{invoiceNumber}} du {{periodStart}} au {{periodEnd}}",
+  "invoices.outstandingProduct.name": "Solde impay\xE9",
+  "invoices.prorata.paymentForItem": "Paiement au prorata pour",
+  "invoices.prorata.refundForItem": "Remboursement au prorata pour",
+  "subscriptions.closingChargeName": "Frais de cl\xF4ture pour abonnement",
+  "subscriptions.correction": "Ajustement p\xE9riode pr\xE9c\xE9dente",
+  "subscriptions.updates.addCoupon": "Ajout du coupon {{couponName}}",
+  "subscriptions.updates.addProduct": "Ajout {{productName}}",
+  "subscriptions.updates.removeCoupon": "Retrait du coupon {{couponName}}",
+  "subscriptions.updates.removeProduct": "Retrait {{productName}}",
+  "subscriptions.updates.unit": "unit\xE9s",
+  "subscriptions.updates.updateCount": "Mise \xE0 jour {{productName}} ({{previousCount}} \u2192 {{newCount}} {{unit}})",
+  "subscriptions.updates.updateCount.description.full.committed.invoiced": "Un minimum engag\xE9 de {{committedCount}} a \xE9t\xE9 appliqu\xE9 pour la p\xE9riode compl\xE8te.",
+  "subscriptions.updates.updateCount.description.full.committed.not_invoiced": "Montant de {{amount}} (avec un minimum engag\xE9 de {{committedCount}}) non factur\xE9 pour la p\xE9riode compl\xE8te",
+  "subscriptions.updates.updateCount.description.full.not_committed.invoiced": "Cette ligne a \xE9t\xE9 factur\xE9e pour la p\xE9riode compl\xE8te",
+  "subscriptions.updates.updateCount.description.full.not_committed.not_invoiced": "Montant de {{amount}} non factur\xE9 pour la p\xE9riode compl\xE8te",
+  "subscriptions.updates.updateCount.description.prorata.committed.invoiced": "Un minimum engag\xE9 de {{committedCount}} a \xE9t\xE9 appliqu\xE9 pour la p\xE9riode proratis\xE9e.",
+  "subscriptions.updates.updateCount.description.prorata.committed.not_invoiced": "Montant de {{amount}} (avec un minimum engag\xE9 de {{committedCount}}) non factur\xE9 pour la p\xE9riode proratis\xE9e",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.invoiced": "Cette ligne a \xE9t\xE9 factur\xE9e pour la p\xE9riode proratis\xE9e",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.not_invoiced": "Montant de {{amount}} non factur\xE9 pour la p\xE9riode proratis\xE9e",
+  "subscriptions.updates.updatePrices": "Mise \xE0 jour des prix pour {{productName}}"
+};
+
+// ../hyperline-i18n/build/locales/it.js
+var it = {
+  "accounting.revrec.creditLineDescription": "Riconoscere i ricavi \u2013 programma {{scheduleId}}, periodo {{periodDate}}",
+  "accounting.revrec.debitLineDescription": "Diminuzione dei ricavi differiti \u2013 programma {{scheduleId}}, periodo {{periodDate}}",
+  "accounting.revrec.discountCreditLineDescription": "Riconoscere il contra-ricavo (sconto) \u2013 programma {{scheduleId}}, periodo {{periodDate}}",
+  "accounting.revrec.discountDebitLineDescription": "Diminuzione dello sconto differito \u2013 programma {{scheduleId}}, periodo {{periodDate}}",
+  "accounting.revrec.entryDescription": "Riconoscimento dei ricavi per il programma {{scheduleId}}, periodo {{periodStart}} - {{periodEnd}}",
+  "creditNotes.refundChargeName": "Rimborso per fattura",
+  "credits.bundleOf": "{{productName}} - Pacchetto di {{creditCount}} crediti",
+  "credits.unitsOf": "{{productName}} - {{creditCount}} crediti",
+  "einvoicing.paymentFromWallet": "Pagamento dal portafoglio",
+  "einvoicing.paymentProcessed": "Pagamento elaborato",
+  "einvoicing.paymentReceived": "Pagamento ricevuto",
+  "invoices.outstandingProduct.description": "Importo insoluto della fattura{{invoiceNumber}} emessa il {{date}}",
+  "invoices.outstandingProduct.descriptionPeriod": "Importo insoluto della fattura{{invoiceNumber}} dal {{periodStart}} al {{periodEnd}}",
+  "invoices.outstandingProduct.name": "Saldo insoluto",
+  "invoices.prorata.paymentForItem": "Pagamento proporzionale per",
+  "invoices.prorata.refundForItem": "Rimborso proporzionale per",
+  "subscriptions.closingChargeName": "Costo di chiusura per abbonamento",
+  "subscriptions.correction": "Correzione periodo precedente",
+  "subscriptions.updates.addCoupon": "Aggiungi coupon {{couponName}}",
+  "subscriptions.updates.addProduct": "Aggiungi {{productName}}",
+  "subscriptions.updates.removeCoupon": "Rimuovi coupon {{couponName}}",
+  "subscriptions.updates.removeProduct": "Rimuovi {{productName}}",
+  "subscriptions.updates.unit": "unit\xE0",
+  "subscriptions.updates.updateCount": "Aggiorna {{productName}} ({{previousCount}} \u2192 {{newCount}} {{unit}})",
+  "subscriptions.updates.updateCount.description.full.committed.invoiced": "\xC8 stato applicato un minimo impegnato di {{committedCount}} per l\u2019intero periodo.",
+  "subscriptions.updates.updateCount.description.full.committed.not_invoiced": "Importo di {{amount}} (con un minimo impegnato di {{committedCount}}) non fatturato per l\u2019intero periodo",
+  "subscriptions.updates.updateCount.description.full.not_committed.invoiced": "Questa voce \xE8 stata fatturata per l\u2019intero periodo",
+  "subscriptions.updates.updateCount.description.full.not_committed.not_invoiced": "Importo di {{amount}} non fatturato per l\u2019intero periodo",
+  "subscriptions.updates.updateCount.description.prorata.committed.invoiced": "\xC8 stato applicato un minimo impegnato di {{committedCount}}.",
+  "subscriptions.updates.updateCount.description.prorata.committed.not_invoiced": "Importo di {{amount}} (con un minimo impegnato di {{committedCount}}) non fatturato per il periodo proporzionato",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.invoiced": "Questa voce \xE8 stata fatturata per il periodo proporzionato",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.not_invoiced": "Importo di {{amount}} non fatturato per il periodo proporzionato",
+  "subscriptions.updates.updatePrices": "Aggiorna prezzi per {{productName}}"
+};
+
+// ../hyperline-i18n/build/locales/nl.js
+var nl = {
+  "accounting.revrec.creditLineDescription": "Omzet erkennen \u2013 schema {{scheduleId}}, periode {{periodDate}}",
+  "accounting.revrec.debitLineDescription": "Uitgestelde omzet verlagen \u2013 schema {{scheduleId}}, periode {{periodDate}}",
+  "accounting.revrec.discountCreditLineDescription": "Omzetvermindering (korting) erkennen \u2013 schema {{scheduleId}}, periode {{periodDate}}",
+  "accounting.revrec.discountDebitLineDescription": "Uitgestelde korting verlagen \u2013 schema {{scheduleId}}, periode {{periodDate}}",
+  "accounting.revrec.entryDescription": "Omzeterkenning voor schema {{scheduleId}}, periode {{periodStart}} - {{periodEnd}}",
+  "creditNotes.refundChargeName": "Terugbetaling voor factuur",
+  "credits.bundleOf": "{{productName}} - Bundel van {{creditCount}} credits",
+  "credits.unitsOf": "{{productName}} - {{creditCount}} credits",
+  "einvoicing.paymentFromWallet": "Betaling uit tegoed",
+  "einvoicing.paymentProcessed": "Betaling verwerkt",
+  "einvoicing.paymentReceived": "Betaling ontvangen",
+  "invoices.outstandingProduct.description": "Onbetaald bedrag van de factuur{{invoiceNumber}} uitgegeven op {{date}}",
+  "invoices.outstandingProduct.descriptionPeriod": "Onbetaald bedrag van de factuur{{invoiceNumber}} van {{periodStart}} tot {{periodEnd}}",
+  "invoices.outstandingProduct.name": "Openstaand saldo",
+  "invoices.prorata.paymentForItem": "Gedeeltelijke betaling voor",
+  "invoices.prorata.refundForItem": "Gedeeltelijke terugbetaling voor",
+  "subscriptions.closingChargeName": "Afsluitkosten voor abonnement",
+  "subscriptions.correction": "Aanpassing vorige periode",
+  "subscriptions.updates.addCoupon": "Coupon toevoegen {{couponName}}",
+  "subscriptions.updates.addProduct": "{{productName}} toevoegen",
+  "subscriptions.updates.removeCoupon": "Coupon verwijderen {{couponName}}",
+  "subscriptions.updates.removeProduct": "{{productName}} verwijderen",
+  "subscriptions.updates.unit": "eenheden",
+  "subscriptions.updates.updateCount": "Bijwerken {{productName}} aantal ({{previousCount}} \u2192 {{newCount}} {{unit}})",
+  "subscriptions.updates.updateCount.description.full.committed.invoiced": "Een minimaal toegezegd aantal van {{committedCount}} is toegepast voor de volledige periode.",
+  "subscriptions.updates.updateCount.description.full.committed.not_invoiced": "Bedrag van {{amount}} (met een minimaal toegezegd aantal van {{committedCount}}) niet gefactureerd voor de volledige periode",
+  "subscriptions.updates.updateCount.description.full.not_committed.invoiced": "Deze regel is gefactureerd voor de volledige periode",
+  "subscriptions.updates.updateCount.description.full.not_committed.not_invoiced": "Bedrag van {{amount}} niet gefactureerd voor de volledige periode",
+  "subscriptions.updates.updateCount.description.prorata.committed.invoiced": "Een minimaal toegezegd aantal van {{committedCount}} is toegepast.",
+  "subscriptions.updates.updateCount.description.prorata.committed.not_invoiced": "Bedrag van {{amount}} (met een minimaal toegezegd aantal van {{committedCount}}) niet gefactureerd voor de geproportioneerde periode",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.invoiced": "Deze regel is gefactureerd voor de geproportioneerde periode",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.not_invoiced": "Bedrag van {{amount}} niet gefactureerd voor de geproportioneerde periode",
+  "subscriptions.updates.updatePrices": "Prijzen bijwerken voor {{productName}}"
+};
+
+// ../hyperline-i18n/build/locales/pl.js
+var pl = {
+  "accounting.revrec.creditLineDescription": "Rozpoznanie przychodu \u2013 harmonogram {{scheduleId}}, okres {{periodDate}}",
+  "accounting.revrec.debitLineDescription": "Zmniejszenie przychod\xF3w przysz\u0142ych okres\xF3w \u2013 harmonogram {{scheduleId}}, okres {{periodDate}}",
+  "accounting.revrec.discountCreditLineDescription": "Rozpoznanie kontra-przychodu (rabat) \u2013 harmonogram {{scheduleId}}, okres {{periodDate}}",
+  "accounting.revrec.discountDebitLineDescription": "Zmniejszenie odroczonego rabatu \u2013 harmonogram {{scheduleId}}, okres {{periodDate}}",
+  "accounting.revrec.entryDescription": "Rozpoznanie przychodu dla harmonogramu {{scheduleId}}, okres {{periodStart}} - {{periodEnd}}",
+  "creditNotes.refundChargeName": "Zwrot za faktur\u0119",
+  "credits.bundleOf": "{{productName}} - Pakiet {{creditCount}} kredyt\xF3w",
+  "credits.unitsOf": "{{productName}} - {{creditCount}} kredyt\xF3w",
+  "einvoicing.paymentFromWallet": "P\u0142atno\u015B\u0107 z portfela",
+  "einvoicing.paymentProcessed": "P\u0142atno\u015B\u0107 przetworzona",
+  "einvoicing.paymentReceived": "P\u0142atno\u015B\u0107 otrzymana",
+  "invoices.outstandingProduct.description": "Nieop\u0142acona kwota z faktury{{invoiceNumber}} wystawionej {{date}}",
+  "invoices.outstandingProduct.descriptionPeriod": "Nieop\u0142acona kwota z faktury{{invoiceNumber}} od {{periodStart}} do {{periodEnd}}",
+  "invoices.outstandingProduct.name": "Niezap\u0142acone saldo",
+  "invoices.prorata.paymentForItem": "P\u0142atno\u015B\u0107 proporcjonalna za",
+  "invoices.prorata.refundForItem": "Zwrot proporcjonalny za",
+  "subscriptions.closingChargeName": "Op\u0142ata za zamkni\u0119cie subskrypcji",
+  "subscriptions.correction": "Korekta poprzedniego okresu",
+  "subscriptions.updates.addCoupon": "Dodaj kupon {{couponName}}",
+  "subscriptions.updates.addProduct": "Dodaj {{productName}}",
+  "subscriptions.updates.removeCoupon": "Usu\u0144 kupon {{couponName}}",
+  "subscriptions.updates.removeProduct": "Usu\u0144 {{productName}}",
+  "subscriptions.updates.unit": "jednostki",
+  "subscriptions.updates.updateCount": "Aktualizuj {{productName}} liczba ({{previousCount}} \u2192 {{newCount}} {{unit}})",
+  "subscriptions.updates.updateCount.description.full.committed.invoiced": "Zastosowano minimaln\u0105 zobowi\u0105zan\u0105 ilo\u015B\u0107 {{committedCount}} za pe\u0142ny okres.",
+  "subscriptions.updates.updateCount.description.full.committed.not_invoiced": "Kwota {{amount}} (z minimaln\u0105 zobowi\u0105zan\u0105 ilo\u015Bci\u0105 {{committedCount}}) niefakturowana za pe\u0142ny okres",
+  "subscriptions.updates.updateCount.description.full.not_committed.invoiced": "Ta pozycja zosta\u0142a zafakturowana za pe\u0142ny okres",
+  "subscriptions.updates.updateCount.description.full.not_committed.not_invoiced": "Kwota {{amount}} niefakturowana za pe\u0142ny okres",
+  "subscriptions.updates.updateCount.description.prorata.committed.invoiced": "Zastosowano minimaln\u0105 zobowi\u0105zan\u0105 ilo\u015B\u0107 {{committedCount}}.",
+  "subscriptions.updates.updateCount.description.prorata.committed.not_invoiced": "Kwota {{amount}} (z minimaln\u0105 zobowi\u0105zan\u0105 ilo\u015Bci\u0105 {{committedCount}}) niefakturowana za okres proporcjonalny",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.invoiced": "Ta pozycja zosta\u0142a zafakturowana za okres proporcjonalny",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.not_invoiced": "Kwota {{amount}} niefakturowana za okres proporcjonalny",
+  "subscriptions.updates.updatePrices": "Aktualizuj ceny dla {{productName}}"
+};
+
+// ../hyperline-i18n/build/locales/pt.js
+var pt = {
+  "accounting.revrec.creditLineDescription": "Reconhecer receita \u2013 cronograma {{scheduleId}}, per\xEDodo {{periodDate}}",
+  "accounting.revrec.debitLineDescription": "Diminui\xE7\xE3o da receita diferida \u2013 cronograma {{scheduleId}}, per\xEDodo {{periodDate}}",
+  "accounting.revrec.discountCreditLineDescription": "Reconhecer contra-receita (desconto) \u2013 cronograma {{scheduleId}}, per\xEDodo {{periodDate}}",
+  "accounting.revrec.discountDebitLineDescription": "Diminui\xE7\xE3o do desconto diferido \u2013 cronograma {{scheduleId}}, per\xEDodo {{periodDate}}",
+  "accounting.revrec.entryDescription": "Reconhecimento de receita para o cronograma {{scheduleId}}, per\xEDodo {{periodStart}} - {{periodEnd}}",
+  "creditNotes.refundChargeName": "Reembolso pela fatura",
+  "credits.bundleOf": "{{productName}} - Pacote de {{creditCount}} cr\xE9ditos",
+  "credits.unitsOf": "{{productName}} - {{creditCount}} cr\xE9ditos",
+  "einvoicing.paymentFromWallet": "Pagamento da carteira",
+  "einvoicing.paymentProcessed": "Pagamento processado",
+  "einvoicing.paymentReceived": "Pagamento recebido",
+  "invoices.outstandingProduct.description": "Valor em aberto da fatura{{invoiceNumber}} emitida em {{date}}",
+  "invoices.outstandingProduct.descriptionPeriod": "Valor em aberto da fatura{{invoiceNumber}} de {{periodStart}} a {{periodEnd}}",
+  "invoices.outstandingProduct.name": "Saldo em aberto",
+  "invoices.prorata.paymentForItem": "Pagamento proporcional por",
+  "invoices.prorata.refundForItem": "Reembolso proporcional por",
+  "subscriptions.closingChargeName": "Taxa de encerramento da assinatura",
+  "subscriptions.correction": "Ajuste do per\xEDodo anterior",
+  "subscriptions.updates.addCoupon": "Adicionar cupom {{couponName}}",
+  "subscriptions.updates.addProduct": "Adicionar {{productName}}",
+  "subscriptions.updates.removeCoupon": "Remover cupom {{couponName}}",
+  "subscriptions.updates.removeProduct": "Remover {{productName}}",
+  "subscriptions.updates.unit": "unidades",
+  "subscriptions.updates.updateCount": "Atualizar {{productName}} quantidade ({{previousCount}} \u2192 {{newCount}} {{unit}})",
+  "subscriptions.updates.updateCount.description.full.committed.invoiced": "Foi aplicado um m\xEDnimo comprometido de {{committedCount}} para o per\xEDodo completo.",
+  "subscriptions.updates.updateCount.description.full.committed.not_invoiced": "Valor de {{amount}} (com um m\xEDnimo comprometido de {{committedCount}}) n\xE3o faturado para o per\xEDodo completo",
+  "subscriptions.updates.updateCount.description.full.not_committed.invoiced": "Esta linha foi faturada para o per\xEDodo completo",
+  "subscriptions.updates.updateCount.description.full.not_committed.not_invoiced": "Valor de {{amount}} n\xE3o faturado para o per\xEDodo completo",
+  "subscriptions.updates.updateCount.description.prorata.committed.invoiced": "Foi aplicado um m\xEDnimo comprometido de {{committedCount}}.",
+  "subscriptions.updates.updateCount.description.prorata.committed.not_invoiced": "Valor de {{amount}} (com um m\xEDnimo comprometido de {{committedCount}}) n\xE3o faturado para o per\xEDodo proporcional",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.invoiced": "Esta linha foi faturada para o per\xEDodo proporcional",
+  "subscriptions.updates.updateCount.description.prorata.not_committed.not_invoiced": "Valor de {{amount}} n\xE3o faturado para o per\xEDodo proporcional",
+  "subscriptions.updates.updatePrices": "Atualizar pre\xE7os para {{productName}}"
+};
+
+// ../hyperline-i18n/build/language.js
+var LanguageSchema = z5.enum(languages.map((language) => language.isoCode));
+var translations = {
+  en,
+  fr,
+  de,
+  it,
+  nl,
+  es,
+  pt,
+  pl
+};
+i18next.init({
+  fallbackLng: "en",
+  keySeparator: false,
+  resources: Object.fromEntries(Object.entries(translations).map(([isoCode, translation]) => [
+    isoCode,
+    { translation }
+    // "translation" is used as namespace name
+  ]))
+});
+
+// ../hyperline-i18n/build/locale.js
+import { z as z6 } from "zod";
+var LocaleSchema = z6.string().refine((value) => {
+  const [language, country] = value.split("-");
+  return LanguageSchema.safeParse(language).success && z6.string().length(2).refine((value2) => value2 === value2.toUpperCase()).safeParse(country).success;
+}, { message: "Invalid locale format" });
+
+// ../hyperline-i18n/build/timezone.js
+import { getTimezones } from "@hyperline/shared";
+import { z as z7 } from "zod";
+var TimezoneSchema = z7.enum(getTimezones().map((timezone) => timezone.name));
+
 // ../hyperline-lib/build/http/helpers/request.js
-import { isValidLanguage } from "@hyperline/i18n";
-import { z as z4 } from "zod";
+import { z as z8 } from "zod";
 
 // ../hyperline-lib/build/http/middlewares/distributedRateLimiter.js
-import { logger as logger2 } from "@hyperline/monitoring";
 import { RateLimiterRedis, RateLimiterRes } from "rate-limiter-flexible";
 
 // ../hyperline-lib/build/http/middlewares/httpErrorHandler.js
@@ -7901,7 +9002,6 @@ import { ZodError as ZodError3 } from "zod";
 // ../hyperline-lib/build/http/middlewares/idempotency.js
 import { createHash as createHash2 } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { logger as logger3 } from "@hyperline/monitoring";
 import { idempotency } from "express-idempotency";
 
 // ../hyperline-lib/build/http/middlewares/httpErrorHandler.js
@@ -7910,15 +9010,11 @@ var isProduction = ["production", "sandbox"].includes(
   process.env.NODE_ENV ?? "production"
 );
 
-// ../hyperline-lib/build/http/helpers/clientIp.js
-import { logger as logger4 } from "@hyperline/monitoring";
-
 // ../hyperline-lib/build/httpClient/error.js
 import axios from "axios";
 var isAxiosError = axios.isAxiosError;
 
 // ../hyperline-lib/build/httpClient/httpClient.js
-import { logHttpRequest, logHttpResponse } from "@hyperline/monitoring";
 import axios2 from "axios";
 import axiosRetry, { isNetworkOrIdempotentRequestError } from "axios-retry";
 import { AxiosError } from "axios";
@@ -7930,13 +9026,13 @@ var recommendedRetryConfig = {
   retryDelay: axiosRetry.exponentialDelay
 };
 function buildHttpClient(dependencies) {
-  const { logger: logger6, config, retry } = dependencies;
-  const client = axios2.create(config);
+  const { logger: logger2, config: config2, retry } = dependencies;
+  const client = axios2.create(config2);
   if (retry !== "none") {
     axiosRetry(client, {
       ...dependencies.retry === "custom" ? dependencies.retryConfig : dependencies.retry === "recommended" ? recommendedRetryConfig : {},
       onRetry(retryCount, error, requestConfig) {
-        logHttpRequest(logger6, toLogRequest(requestConfig), {
+        logHttpRequest(logger2, toLogRequest(requestConfig), {
           postfix: `[EXTERNAL] (attempt ${retryCount})`,
           metadata: {
             // biome-ignore lint/correctness/useParseIntRadix: ignore
@@ -7948,7 +9044,7 @@ function buildHttpClient(dependencies) {
     });
   }
   client.interceptors.request.use((requestConfig) => {
-    logHttpRequest(logger6, toLogRequest(requestConfig), {
+    logHttpRequest(logger2, toLogRequest(requestConfig), {
       postfix: "[EXTERNAL]"
     });
     requestConfig.metadata = { timeStart: /* @__PURE__ */ new Date() };
@@ -7960,14 +9056,14 @@ function buildHttpClient(dependencies) {
     const { config: responseConfig, status } = response;
     const timeStart = responseConfig.metadata.timeStart;
     const responseTime = timeStart ? Date.now() - timeStart : void 0;
-    logHttpResponse(logger6, { request: toLogRequest(responseConfig), statusCode: status }, responseTime);
+    logHttpResponse(logger2, { request: toLogRequest(responseConfig), statusCode: status }, responseTime);
     return response;
   }, (error) => {
     if (error.response) {
       const { config: responseConfig, status } = error.response;
       const timeStart = responseConfig.metadata.timeStart;
       const responseTime = timeStart ? Date.now() - timeStart : void 0;
-      logHttpResponse(logger6, { request: toLogRequest(responseConfig), statusCode: status }, responseTime, { metadata: { error: error.message } });
+      logHttpResponse(logger2, { request: toLogRequest(responseConfig), statusCode: status }, responseTime, { metadata: { error: error.message } });
     }
     return Promise.reject(error);
   });
@@ -7976,20 +9072,19 @@ function buildHttpClient(dependencies) {
 function isTooManyRequestsError(error) {
   return error.response?.status === 429;
 }
-var toLogRequest = (config) => {
+var toLogRequest = (config2) => {
   return {
-    method: config.method ?? "",
-    url: config.url ?? "",
-    path: config.url ?? "",
-    hostname: config.baseURL ?? "",
-    originalUrl: `${config.baseURL}${config.url}`,
-    body: config.data,
+    method: config2.method ?? "",
+    url: config2.url ?? "",
+    path: config2.url ?? "",
+    hostname: config2.baseURL ?? "",
+    originalUrl: `${config2.baseURL}${config2.url}`,
+    body: config2.data,
     headers: {}
   };
 };
 
 // ../hyperline-lib/build/httpRouter/express.js
-import { runWithExecutionContext } from "@hyperline/monitoring";
 import { OpenAPIRegistry as OpenAPIRegistry2, OpenApiGeneratorV31 } from "@asteasolutions/zod-to-openapi";
 import { Router as ExpressRouter } from "express";
 import multer2 from "multer";
@@ -8066,12 +9161,11 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { createHmac } from "node:crypto";
 
 // ../hyperline-mcp/build/session/sessionManager.js
-import { logger as logger5 } from "@hyperline/monitoring";
 import { LRUCache } from "lru-cache";
 
 // build/output.js
-function formatOutput({ data, format: format2 }) {
-  if (format2 === "json") {
+function formatOutput({ data, format: format3 }) {
+  if (format3 === "json") {
     return JSON.stringify(data, null, 2);
   }
   return formatText(data);
@@ -8112,7 +9206,7 @@ ${formatText(value, indent + 2)}`;
 }
 
 // build/http.js
-function createCLIContext({ apiKey, baseUrl, outputFormat, source }) {
+function createCLIContext({ apiKey, baseUrl, outputFormat, source, companyId }) {
   const noop = () => {
   };
   const httpClient = buildHttpClient({
@@ -8126,8 +9220,9 @@ function createCLIContext({ apiKey, baseUrl, outputFormat, source }) {
     }
   });
   return {
+    baseUrl,
     outputFormat,
-    async execute({ method, path: path2, args, queryParamKeys = [], body }) {
+    async execute({ method, path: path2, args, queryParamKeys = [], body, baseUrlOverride }) {
       const { url, params, data } = buildRequestConfig(path2, args, method, queryParamKeys);
       const requestData = body ?? data;
       const hasData = Array.isArray(requestData) ? requestData.length > 0 : requestData != null && Object.keys(requestData).length > 0;
@@ -8137,8 +9232,10 @@ function createCLIContext({ apiKey, baseUrl, outputFormat, source }) {
           url,
           params,
           data: hasData ? requestData : void 0,
+          ...baseUrlOverride ? { baseURL: baseUrlOverride } : {},
           headers: {
-            "Hyperline-Source": source
+            "Hyperline-Source": source,
+            ...companyId ? { "Hyperline-CompanyId": companyId } : {}
           }
         });
         process.stdout.write(formatOutput({ data: response.data, format: outputFormat }));
@@ -8184,7 +9281,7 @@ function isAxiosError2(error) {
 
 // build/bin/hyperline.js
 var program = new Command();
-program.name("hyperline").description("Agent-first CLI for the Hyperline API").version("0.1.0").option("--api-key <key>", "Hyperline API key (overrides HYPERLINE_API_KEY)").option("--base-url <url>", "API base URL (overrides HYPERLINE_API_URL)").option("--output <format>", "Output format: json or text", "text");
+program.name("hyperline").description("Agent-first CLI for the Hyperline API").version("0.1.0").option("--api-key <key>", "Hyperline API key (overrides HYPERLINE_API_KEY)").option("--base-url <url>", "API base URL (overrides HYPERLINE_API_URL)").option("--output <format>", "Output format: json or text", "text").option("--company-id <id>", "Company ID (overrides HYPERLINE_COMPANY_ID and stored selection)");
 program.command("login").description("Authenticate with Hyperline via browser").action(async () => {
   const options = program.opts();
   const baseUrl = await resolveBaseUrl({
@@ -8196,10 +9293,64 @@ program.command("logout").description("Clear stored credentials").action(async (
   await clearCredentials();
   process.stdout.write("Logged out.\n");
 });
+var companyCommand = program.command("company").description("Manage active company");
+companyCommand.command("select").description("Interactively select the active company").action(async () => {
+  const options = program.opts();
+  const baseUrl = await resolveBaseUrl({
+    flagBaseUrl: options.baseUrl
+  });
+  const apiKey = resolveApiKey({
+    flagApiKey: options.apiKey
+  });
+  const accessToken = apiKey ?? await resolveAccessToken();
+  if (!accessToken) {
+    process.stderr.write("Error: No authentication found. Run: hyperline login\n");
+    process.exit(1);
+  }
+  await promptCompanySelection({ baseUrl, accessToken });
+});
+companyCommand.command("set <companyId>").description("Set the active company by ID (for scripts and agents)").action(async (companyId) => {
+  await saveCompanyId({ companyId });
+  process.stdout.write(`Company set to ${companyId}
+`);
+});
+companyCommand.command("list").description("List all accessible companies").action(async () => {
+  const options = program.opts();
+  const baseUrl = await resolveBaseUrl({
+    flagBaseUrl: options.baseUrl
+  });
+  const apiKey = resolveApiKey({
+    flagApiKey: options.apiKey
+  });
+  const accessToken = apiKey ?? await resolveAccessToken();
+  if (!accessToken) {
+    process.stderr.write("Error: No authentication found. Run: hyperline login\n");
+    process.exit(1);
+  }
+  const companies = await fetchCompanies({ baseUrl, accessToken });
+  const currentCompanyId = await resolveCompanyId({});
+  for (const company of companies) {
+    const marker = company.id === currentCompanyId ? " (active)" : "";
+    process.stdout.write(`${company.name} ${company.id}${marker}
+`);
+  }
+});
+companyCommand.command("current").description("Show the currently active company").action(async () => {
+  const companyId = await resolveCompanyId({});
+  if (companyId) {
+    process.stdout.write(`${companyId}
+`);
+  } else {
+    process.stdout.write("No company selected. Run: hyperline company select\n");
+  }
+});
 registerAllCommands(program);
+registerEventsCommands(program);
+var selfAuthCommands = /* @__PURE__ */ new Set(["login", "logout", "company"]);
 program.hook("preAction", async (thisCommand, actionCommand) => {
   const commandName = actionCommand.name();
-  if (commandName === "login" || commandName === "logout")
+  const parentName = actionCommand.parent?.name();
+  if (selfAuthCommands.has(commandName) || selfAuthCommands.has(parentName ?? ""))
     return;
   const options = program.opts();
   const outputFormat = options.output ?? "text";
@@ -8214,11 +9365,15 @@ program.hook("preAction", async (thisCommand, actionCommand) => {
   const baseUrl = await resolveBaseUrl({
     flagBaseUrl: options.baseUrl
   });
+  const companyId = await resolveCompanyId({
+    flagCompanyId: options.companyId
+  });
   const ctx = createCLIContext({
     apiKey: token,
     baseUrl,
     outputFormat,
-    source: apiKey ? "cli" : "cli-oauth"
+    source: "cli",
+    companyId
   });
   thisCommand.setOptionValue("_ctx", ctx);
 });