Conectează-ți sistemele și automatizează fluxurile de lucru cu API-ul Enlivy

curl -G 'https://api.enlivy.com/organizations/<organization_id>/invoices' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=20' \
  --data-urlencode 'include=invoice_prefix,tag_ids,line_items,taxes' \
  --data-urlencode 'include_meta=navigation' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const query = new URLSearchParams({
  page: "1",
  limit: "20",
  include: "invoice_prefix,tag_ids,line_items,taxes",
  include_meta: "navigation",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/invoices?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -G 'https://api.enlivy.com/organizations/<organization_id>/invoices/<invoice_id>' \
  --data-urlencode 'include=invoice_prefix,tag_ids,line_items,taxes' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const invoiceId = "<invoice_id>";

const query = new URLSearchParams({
  include: "invoice_prefix,tag_ids,line_items,taxes",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/invoices/${invoiceId}?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# source (internal), direction (outbound) și type (standard) iau valorile implicite dacă lipsesc.
curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/invoices' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_receiver_user_id": "<org_user_receiver_id>",
  "status": "draft",
  "currency": "EUR",
  "payment_method": "bank_transfer",
  "delivery_method": "email",
  "line_items": [
    {
      "name_lang_map": {
        "en": "Web Development Services"
      },
      "quantity": 10,
      "price": 75,
      "type": "service",
      "organization_tax_class_id": "<tax_class_id>"
    }
  ]
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// source (internal), direction (outbound) și type (standard) iau valorile implicite dacă lipsesc.
const result = await fetch(`${baseUrl}/organizations/${organizationId}/invoices`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // clientul căruia i se emite factura
    organization_receiver_user_id: "<org_user_receiver_id>",
    // draft | pending | sent_email | paid | ...
    status: "draft",
    currency: "EUR",
    // bank_transfer | card_payment | cash | ...
    payment_method: "bank_transfer",
    delivery_method: "email",
    line_items: [
      // sau trimiți organization_product_id ca să facturezi unul dintre produsele tale
      {
        name_lang_map: { en: "Web Development Services" },
        quantity: 10,
        price: 75,
        type: "service",
        organization_tax_class_id: "<tax_class_id>",
      },
    ],
  }),
}).then((response) => response.json());

curl -X PUT 'https://api.enlivy.com/organizations/<organization_id>/invoices/<invoice_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "status": "paid",
  "payment_method": "bank_transfer",
  "due_at": "2026-07-31T09:00:00Z"
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const invoiceId = "<invoice_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/invoices/${invoiceId}`, {
  method: "PUT",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // actualizare parțială: se modifică doar câmpurile trimise
    status: "paid",
    payment_method: "bank_transfer",
    due_at: "2026-07-31T09:00:00Z",
  }),
}).then((response) => response.json());

# status: pending | active | payment_method_required | paused | cancelling | completed | cancelled
curl -G 'https://api.enlivy.com/organizations/<organization_id>/billing-schedules' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=20' \
  --data-urlencode 'status=active' \
  --data-urlencode 'direction=outbound' \
  --data-urlencode 'include=receiver_user,phases,payments' \
  --data-urlencode 'include_meta=navigation' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// status: pending | active | payment_method_required | paused | cancelling | completed | cancelled
const query = new URLSearchParams({
  page: "1",
  limit: "20",
  status: "active",
  direction: "outbound",
  include: "receiver_user,phases,payments",
  include_meta: "navigation",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/billing-schedules?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# includes: sender_user, receiver_user, contract, billing_package,
# subscription_term, phases, payments, deleted_by_user
curl -G 'https://api.enlivy.com/organizations/<organization_id>/billing-schedules/<billing_schedule_id>' \
  --data-urlencode 'include=phases,payments,receiver_user,billing_package' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const billingScheduleId = "<billing_schedule_id>";

// includes: sender_user, receiver_user, contract, billing_package,
// subscription_term, phases, payments, deleted_by_user
const query = new URLSearchParams({
  include: "phases,payments,receiver_user,billing_package",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/billing-schedules/${billingScheduleId}?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/billing-schedules' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "management_type": "app_managed",
  "direction": "outbound",
  "status": "active",
  "organization_sender_user_id": "<org_user_sender_id>",
  "organization_receiver_user_id": "<org_user_receiver_id>",
  "currency": "EUR",
  "payment_method": "stripe_card_payment",
  "organization_user_payment_method_id": "<payment_method_id>",
  "name_lang_map": {
    "en": "Monthly Retainer"
  },
  "note_lang_map": {
    "en": "Includes support and hosting."
  },
  "is_email_notifications_active": true,
  "email_notifications_to": "billing@acme.example",
  "customer_can_reconfigure": false,
  "customer_can_cancel": true,
  "customer_can_pause": false,
  "phases": [
    {
      "frequency": "monthly",
      "execute_after": "2026-08-01",
      "max_occurrences": 12,
      "due_date_type": "custom_days",
      "due_date_days": 14,
      "order": 0,
      "line_items": [
        {
          "name_lang_map": {
            "en": "Retainer"
          },
          "quantity": 1,
          "price": 500,
          "organization_tax_class_id": "<tax_class_id>"
        },
        {
          "organization_product_id": "<product_id>",
          "quantity": 2,
          "price": 49.9
        }
      ]
    }
  ]
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/billing-schedules`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // exemplul acoperă doar app_managed
    management_type: "app_managed",
    // outbound = tu facturezi un client; inbound = tu ești facturat
    direction: "outbound",
    // facturarea începe imediat
    status: "active",
    // cel care facturează (tu)
    organization_sender_user_id: "<org_user_sender_id>",
    // clientul (obligatoriu pentru outbound)
    organization_receiver_user_id: "<org_user_receiver_id>",
    currency: "EUR",
    // bank_transfer | card_payment | stripe_card_payment | paypal | cash | paid_by_personal_funds
    payment_method: "stripe_card_payment",
    // cardul salvat de pe care se încasează automat (trebuie să fie al destinatarului)
    organization_user_payment_method_id: "<payment_method_id>",
    name_lang_map: {
      // hărți pe limbi, nu texte simple
      en: "Monthly Retainer",
    },
    note_lang_map: { en: "Includes support and hosting." },
    is_email_notifications_active: true,
    email_notifications_to: "billing@acme.example",
    // ce poate face singur clientul din portal
    customer_can_reconfigure: false,
    customer_can_cancel: true,
    customer_can_pause: false,
    // totalurile și datele (total, paid_total, starts_at, ends_at, next_payment_create_at)
    // sunt calculate de Enlivy, NU le trimiți.
    // phases sunt valabile DOAR pentru app_managed (stripe_hosted le respinge). Maximum 20.
    phases: [
      {
        // weekly | biweekly | monthly | yearly
        frequency: "monthly",
        // data primei rulări pentru această fază
        execute_after: "2026-08-01",
        // se oprește după N facturi (lipsă = fără sfârșit)
        max_occurrences: 12,
        // immediate | end_of_month | custom_days
        due_date_type: "custom_days",
        // obligatoriu doar când due_date_type = custom_days
        due_date_days: 14,
        order: 0,
        line_items: [
          {
            name_lang_map: {
              // obligatoriu dacă nu trimiți organization_product_id
              en: "Retainer",
            },
            quantity: 1,
            // suma: zecimal cu semn, în unități ÎNTREGI (nu în cenți)
            price: 500,
            organization_tax_class_id: "<tax_class_id>",
          },
          {
            // preia numele și taxele implicite din produs
            organization_product_id: "<product_id>",
            quantity: 2,
            price: 49.9,
          },
        ],
      },
    ],
  }),
}).then((response) => response.json());

# Pachetul comercial aduce fazele și elementele, așa că nu le trimiți aici.
curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/billing-schedules/from-billing-package' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_billing_package_id": "<billing_package_id>",
  "organization_billing_package_subscription_term_id": "<subscription_term_id>",
  "selected_group_items": [
    {
      "id": "<group_item_id>",
      "quantity": 1
    },
    {
      "id": "<other_group_item_id>",
      "quantity": 3
    }
  ],
  "organization_sender_user_id": "<org_user_sender_id>",
  "organization_receiver_user_id": "<org_user_receiver_id>",
  "status": "active",
  "payment_method": "bank_transfer",
  "currency": "EUR",
  "start_at": "2026-11-01",
  "is_email_notifications_active": true
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// Pachetul comercial aduce fazele și elementele, așa că nu le trimiți aici.
const result = await fetch(`${baseUrl}/organizations/${organizationId}/billing-schedules/from-billing-package`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // atașezi un pachet comercial cu ABONAMENT; el definește fazele și elementele
    organization_billing_package_id: "<billing_package_id>",
    // opțional: alegi varianta de recurență; lipsă = cea implicită a pachetului
    organization_billing_package_subscription_term_id: "<subscription_term_id>",
    // opțional: alegi ce elemente din grupurile pachetului intră (și cantitățile)
    selected_group_items: [
      { id: "<group_item_id>", quantity: 1 },
      { id: "<other_group_item_id>", quantity: 3 },
    ],
    organization_sender_user_id: "<org_user_sender_id>",
    organization_receiver_user_id: "<org_user_receiver_id>",
    // pending | active
    status: "active",
    payment_method: "bank_transfer",
    currency: "EUR",
    start_at: "2026-11-01",
    is_email_notifications_active: true,
  }),
}).then((response) => response.json());

# ca să schimbi CE se facturează într-un plan de plată creat din pachet,
# folosești /reconfigure de mai jos, nu editarea de aici.
curl -X PUT 'https://api.enlivy.com/organizations/<organization_id>/billing-schedules/<billing_schedule_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "status": "paused",
  "note_lang_map": {
    "en": "Paused at customer request."
  },
  "is_email_notifications_active": false,
  "customer_can_cancel": true
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const billingScheduleId = "<billing_schedule_id>";

// ca să schimbi CE se facturează într-un plan de plată creat din pachet,
// folosești /reconfigure de mai jos, nu editarea de aici.
const result = await fetch(`${baseUrl}/organizations/${organizationId}/billing-schedules/${billingScheduleId}`, {
  method: "PUT",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // ciclu de viață: active <-> paused; setezi "cancelling" ca să se oprească la finalul ciclului
    status: "paused",
    note_lang_map: { en: "Paused at customer request." },
    is_email_notifications_active: false,
    customer_can_cancel: true,
  }),
}).then((response) => response.json());

# 1. Previzualizare: nu se aplică nimic; primești noua componență și proratarea
curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/billing-schedules/<billing_schedule_id>/preview-reconfigure' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_billing_package_id": "<billing_package_id>",
  "organization_billing_package_subscription_term_id": "<subscription_term_id>",
  "selected_group_items": [
    {
      "id": "<group_item_id>",
      "quantity": 2,
      "price_override": 39,
      "pricing_currency": "EUR"
    }
  ],
  "custom_line_items": [
    {
      "name_lang_map": {
        "en": "One-off setup"
      },
      "quantity": 1,
      "price": 150
    }
  ],
  "proration_mode": "prorate_next_invoice"
}'

# 2. Aplici
curl -X PUT 'https://api.enlivy.com/organizations/<organization_id>/billing-schedules/<billing_schedule_id>/reconfigure' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_billing_package_id": "<billing_package_id>",
  "organization_billing_package_subscription_term_id": "<subscription_term_id>",
  "selected_group_items": [
    {
      "id": "<group_item_id>",
      "quantity": 2,
      "price_override": 39,
      "pricing_currency": "EUR"
    }
  ],
  "custom_line_items": [
    {
      "name_lang_map": {
        "en": "One-off setup"
      },
      "quantity": 1,
      "price": 150
    }
  ],
  "proration_mode": "prorate_next_invoice"
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const billingScheduleId = "<billing_schedule_id>";

const headers = {
  Authorization: `Bearer ${token}`,
  Accept: "application/json",
  "Content-Type": "application/json",
};

// 1. Previzualizare: nu se aplică nimic; primești noua componență și proratarea
const result1 = await fetch(`${baseUrl}/organizations/${organizationId}/billing-schedules/${billingScheduleId}/preview-reconfigure`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    organization_billing_package_id: "<billing_package_id>",
    organization_billing_package_subscription_term_id: "<subscription_term_id>",
    selected_group_items: [
      // price_override + pricing_currency îți permit un preț diferit de cel din pachet
      {
        id: "<group_item_id>",
        quantity: 2,
        price_override: 39,
        pricing_currency: "EUR",
      },
    ],
    custom_line_items: [{ name_lang_map: { en: "One-off setup" }, quantity: 1, price: 150 }],
    // cum se facturează schimbarea: none | prorate_immediately | prorate_next_invoice
    // (prorate_immediately cere un plan de plată activ)
    proration_mode: "prorate_next_invoice",
  }),
}).then((response) => response.json());

// 2. Aplici
const result2 = await fetch(`${baseUrl}/organizations/${organizationId}/billing-schedules/${billingScheduleId}/reconfigure`, {
  method: "PUT",
  headers,
  body: JSON.stringify({
    organization_billing_package_id: "<billing_package_id>",
    organization_billing_package_subscription_term_id: "<subscription_term_id>",
    selected_group_items: [
      // price_override + pricing_currency îți permit un preț diferit de cel din pachet
      {
        id: "<group_item_id>",
        quantity: 2,
        price_override: 39,
        pricing_currency: "EUR",
      },
    ],
    custom_line_items: [{ name_lang_map: { en: "One-off setup" }, quantity: 1, price: 150 }],
    // cum se facturează schimbarea: none | prorate_immediately | prorate_next_invoice
    // (prorate_immediately cere un plan de plată activ)
    proration_mode: "prorate_next_invoice",
  }),
}).then((response) => response.json());

# analyticsType: summary | history_monthly
curl -G 'https://api.enlivy.com/organizations/<organization_id>/billing-schedules/analytics/summary' \
  --data-urlencode 'start_date=2026-01-01T00:00:00Z' \
  --data-urlencode 'end_date=2026-12-31T23:59:59Z' \
  --data-urlencode 'direction=outbound' \
  --data-urlencode 'convert_to_currency=EUR' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const analyticsType = "summary";

// analyticsType: summary | history_monthly
const query = new URLSearchParams({
  start_date: "2026-01-01T00:00:00Z",
  end_date: "2026-12-31T23:59:59Z",
  direction: "outbound",
  convert_to_currency: "EUR",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/billing-schedules/analytics/${analyticsType}?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# ștergere reversibilă; restaurezi cu POST /billing-schedules/restore/{scheduleId}
curl -X DELETE 'https://api.enlivy.com/organizations/<organization_id>/billing-schedules/<billing_schedule_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const billingScheduleId = "<billing_schedule_id>";

// ștergere reversibilă; restaurezi cu POST /billing-schedules/restore/{scheduleId}
const result = await fetch(`${baseUrl}/organizations/${organizationId}/billing-schedules/${billingScheduleId}`, {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# 1. Afli instituțiile eligibile pentru factură.
#    invoice.peppol_exchange_push_options listează instituțiile către care poți trimite;
#    invoice.peppol_exchanges_pushed le listează pe cele deja trimise.
curl 'https://api.enlivy.com/organizations/<organization_id>/invoices/<invoice_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

# 2. Trimiți către o anumită instituție. Id-ul este un text, de exemplu "anaf" (România / ANAF).
# fără corp: documentul este factura
curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/invoices/<invoice_id>/peppol/anaf' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

# Răspunsul este înregistrarea schimbului în rețea. Urmărești `status`:
# pending | processing | success | success_in_exchange_queue | success_pending_archive
# | change_required | rejected | rejected_at_exchange | failed | failed_credentials_expired
# Dacă instituția nu poate fi contactată, primești HTTP 503.

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const invoiceId = "<invoice_id>";
const institution = "anaf";

const headers = {
  Authorization: `Bearer ${token}`,
  Accept: "application/json",
};

// 1. Afli instituțiile eligibile pentru factură.
//    invoice.peppol_exchange_push_options listează instituțiile către care poți trimite;
//    invoice.peppol_exchanges_pushed le listează pe cele deja trimise.
const invoice = await fetch(`${baseUrl}/organizations/${organizationId}/invoices/${invoiceId}`, {
  method: "GET",
  headers,
}).then((response) => response.json());

// 2. Trimiți către o anumită instituție. Id-ul este un text, de exemplu "anaf" (România / ANAF).
// fără corp: documentul este factura
const exchange = await fetch(`${baseUrl}/organizations/${organizationId}/invoices/${invoiceId}/peppol/${institution}`, {
  method: "POST",
  headers,
}).then((response) => response.json());

// Răspunsul este înregistrarea schimbului în rețea. Urmărești `status`:
// pending | processing | success | success_in_exchange_queue | success_pending_archive
// | change_required | rejected | rejected_at_exchange | failed | failed_credentials_expired
// Dacă instituția nu poate fi contactată, primești HTTP 503.

# filtre: status, organization_invoice_id, invoice_state (starea facturii legate),
# created_at_from/to, updated_at_from/to, ids
curl -G 'https://api.enlivy.com/organizations/<organization_id>/invoices/network-exchanges' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=20' \
  --data-urlencode 'status=success' \
  --data-urlencode 'include=invoice' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// filtre: status, organization_invoice_id, invoice_state (starea facturii legate),
// created_at_from/to, updated_at_from/to, ids
const query = new URLSearchParams({
  page: "1",
  limit: "20",
  status: "success",
  include: "invoice",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/invoices/network-exchanges?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# includes: organization, invoice, parsed_data (UBL-ul interpretat, ca date structurate), tag_ids
curl -G 'https://api.enlivy.com/organizations/<organization_id>/invoices/network-exchanges/<peppol_network_exchange_id>' \
  --data-urlencode 'include=parsed_data,invoice' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const peppolNetworkExchangeId = "<peppol_network_exchange_id>";

// includes: organization, invoice, parsed_data (UBL-ul interpretat, ca date structurate), tag_ids
const query = new URLSearchParams({
  include: "parsed_data,invoice",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/invoices/network-exchanges/${peppolNetworkExchangeId}?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -G 'https://api.enlivy.com/organizations/<organization_id>/invoices/network-exchanges/anaf/pull' \
  --data-urlencode 'date_from=2026-07-01' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const institutionId = "anaf";

const query = new URLSearchParams({
  date_from: "2026-07-01",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/invoices/network-exchanges/${institutionId}/pull?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# documentul UBL / XML semnat
curl 'https://api.enlivy.com/organizations/<organization_id>/invoices/network-exchanges/<peppol_network_exchange_id>/download' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  --remote-name --remote-header-name

# semnătura digitală detașată
curl 'https://api.enlivy.com/organizations/<organization_id>/invoices/network-exchanges/<peppol_network_exchange_id>/download-signature' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  --remote-name --remote-header-name

# versiunea PDF, ușor de citit
curl 'https://api.enlivy.com/organizations/<organization_id>/invoices/network-exchanges/<peppol_network_exchange_id>/download-pdf' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  --remote-name --remote-header-name

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const peppolNetworkExchangeId = "<peppol_network_exchange_id>";

const headers = {
  Authorization: `Bearer ${token}`,
};

// documentul UBL / XML semnat
const xml = await fetch(`${baseUrl}/organizations/${organizationId}/invoices/network-exchanges/${peppolNetworkExchangeId}/download`, {
  method: "GET",
  headers,
}).then((response) => response.blob());

// semnătura digitală detașată
const signature = await fetch(`${baseUrl}/organizations/${organizationId}/invoices/network-exchanges/${peppolNetworkExchangeId}/download-signature`, {
  method: "GET",
  headers,
}).then((response) => response.blob());

// versiunea PDF, ușor de citit
const pdf = await fetch(`${baseUrl}/organizations/${organizationId}/invoices/network-exchanges/${peppolNetworkExchangeId}/download-pdf`, {
  method: "GET",
  headers,
}).then((response) => response.blob());

curl 'https://api.enlivy.com/organizations/<organization_id>/invoices/network-exchanges/<peppol_network_exchange_id>/information' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const peppolNetworkExchangeId = "<peppol_network_exchange_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/invoices/network-exchanges/${peppolNetworkExchangeId}/information`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -G 'https://api.enlivy.com/organizations/<organization_id>/bank-transaction-cost-types' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=50' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const query = new URLSearchParams({
  page: "1",
  limit: "50",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/bank-transaction-cost-types?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/bank-transaction-cost-types' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "title_lang_map": {
    "en": "Client Payment",
    "ro": "Încasare client"
  },
  "connection_required": true,
  "connection_types": [
    "invoice",
    "receipt"
  ],
  "organization_bank_transaction_cost_type_id": null
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/bank-transaction-cost-types`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    title_lang_map: {
      en: "Client Payment",
      // hartă pe limbi
      ro: "Încasare client",
    },
    // o tranzacție de acest tip trebuie legată de o entitate de business?
    connection_required: true,
    // de ce tipuri de entități poate fi legată (obligatoriu când connection_required = true)
    // opțiuni: invoice | receipt | payslip | bank_transaction | user
    connection_types: [
      "invoice",
      "receipt",
    ],
    // opțional: tipul de cost părinte, pentru o categorie ierarhică
    organization_bank_transaction_cost_type_id: null,
  }),
}).then((response) => response.json());

# state: backlog | classified | connected | connected_partially | danger | trashed
# pentru tranzacțiile legate de o anumită entitate, trimiți AMBII parametri:
# `&connection_entity_type=invoice&connection_entity_id=invoice_id` +
# căutare în text cu q=... (minimum 3 caractere) în loc de ids
curl -G 'https://api.enlivy.com/organizations/<organization_id>/bank-transactions' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=20' \
  --data-urlencode 'state=backlog' \
  --data-urlencode 'direction=inbound' \
  --data-urlencode 'include=cost_type,connection_entities,bank_account' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// state: backlog | classified | connected | connected_partially | danger | trashed
// pentru tranzacțiile legate de o anumită entitate, trimiți AMBII parametri:
// `&connection_entity_type=invoice&connection_entity_id=invoice_id` +
// căutare în text cu q=... (minimum 3 caractere) în loc de ids
const query = new URLSearchParams({
  page: "1",
  limit: "20",
  state: "backlog",
  direction: "inbound",
  include: "cost_type,connection_entities,bank_account",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/bank-transactions?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# includes: organization, bank_account, cost_type, connection_entities, deleted_by_user, tag_ids
curl -G 'https://api.enlivy.com/organizations/<organization_id>/bank-transactions/<bank_transaction_id>' \
  --data-urlencode 'include=cost_type,connection_entities,bank_account' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const bankTransactionId = "<bank_transaction_id>";

// includes: organization, bank_account, cost_type, connection_entities, deleted_by_user, tag_ids
const query = new URLSearchParams({
  include: "cost_type,connection_entities,bank_account",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/bank-transactions/${bankTransactionId}?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# starea se stabilește prin clasificare (implicit "backlog"), nu trebuie trimisă.
# opțional, clasifici direct cu organization_bank_transaction_cost_type_id + connection_entities (vezi mai jos).
curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/bank-transactions' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "hash": "unique-dedupe-key",
  "title": "Incoming transfer from Acme Studio",
  "amount": 1200,
  "currency": "EUR",
  "organization_bank_account_id": "<bank_account_id>",
  "sender_label": "ACME STUDIO SRL",
  "note": "Invoice #2026-0142 settlement"
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// starea se stabilește prin clasificare (implicit "backlog"), nu trebuie trimisă.
// opțional, clasifici direct cu organization_bank_transaction_cost_type_id + connection_entities (vezi mai jos).
const result = await fetch(`${baseUrl}/organizations/${organizationId}/bank-transactions`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // obligatoriu; unic în cadrul unui cont bancar (cheia de deduplicare la import)
    hash: "unique-dedupe-key",
    title: "Incoming transfer from Acme Studio",
    // suma: zecimal cu semn, în unități ÎNTREGI (nu în cenți)
    amount: 1200,
    // direcția REZULTĂ din semn (pozitiv = încasare, negativ = plată)
    currency: "EUR",
    organization_bank_account_id: "<bank_account_id>",
    // numele contrapartidei, așa cum apare în extrasul băncii
    sender_label: "ACME STUDIO SRL",
    note: "Invoice #2026-0142 settlement",
  }),
}).then((response) => response.json());

curl -X PUT 'https://api.enlivy.com/organizations/<organization_id>/bank-transactions/<bank_transaction_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_bank_transaction_cost_type_id": "<cost_type_id>",
  "connection_entities": [
    {
      "connection_entity_type": "invoice",
      "connection_entity_id": "<invoice_id>",
      "amount": 1000
    },
    {
      "connection_entity_type": "receipt",
      "connection_entity_id": "<receipt_id>",
      "amount": 200
    }
  ]
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const bankTransactionId = "<bank_transaction_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/bank-transactions/${bankTransactionId}`, {
  method: "PUT",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // 1. Clasifici: atribui un tip de cost. Starea trece din backlog în classified.
    organization_bank_transaction_cost_type_id: "<cost_type_id>",
    // 2. Reconciliezi: legi tranzacția de ce plătește.
    //    connection_entity_type trebuie să fie unul dintre connection_types permise de tipul de cost.
    //    Lista este un UPSERT:
    //        { connection_entity_type, connection_entity_id, amount }  -> creează o legătură
    //        { id }                                                    -> păstrează o legătură existentă
    //        { id, _deleted: true }                                    -> elimină o legătură
    //    (o legătură existentă lăsată afară NU se șterge)
    //    Sume care acoperă toată tranzacția -> "connected"; parțial -> "connected_partially".
    connection_entities: [
      {
        connection_entity_type: "invoice",
        connection_entity_id: "<invoice_id>",
        amount: 1000,
      },
      {
        connection_entity_type: "receipt",
        connection_entity_id: "<receipt_id>",
        amount: 200,
      },
    ],
  }),
}).then((response) => response.json());

# analyticsType: summary | history_monthly
curl -G 'https://api.enlivy.com/organizations/<organization_id>/bank-transactions/analytics/summary' \
  --data-urlencode 'start_date=2026-01-01' \
  --data-urlencode 'end_date=2026-12-31' \
  --data-urlencode 'direction=outbound' \
  --data-urlencode 'convert_to_currency=EUR' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const analyticsType = "summary";

// analyticsType: summary | history_monthly
const query = new URLSearchParams({
  start_date: "2026-01-01",
  end_date: "2026-12-31",
  direction: "outbound",
  convert_to_currency: "EUR",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/bank-transactions/analytics/${analyticsType}?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# ștergere reversibilă; restaurezi cu POST /bank-transactions/restore/{transactionId}
curl -X DELETE 'https://api.enlivy.com/organizations/<organization_id>/bank-transactions/<bank_transaction_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const bankTransactionId = "<bank_transaction_id>";

// ștergere reversibilă; restaurezi cu POST /bank-transactions/restore/{transactionId}
const result = await fetch(`${baseUrl}/organizations/${organizationId}/bank-transactions/${bankTransactionId}`, {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# filtre: name, description, ids
# include tax_rates_overview pentru un rezumat al cotelor fiecărei clase
curl -G 'https://api.enlivy.com/organizations/<organization_id>/tax-classes' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=20' \
  --data-urlencode 'include=tax_rates_overview' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// filtre: name, description, ids
// include tax_rates_overview pentru un rezumat al cotelor fiecărei clase
const query = new URLSearchParams({
  page: "1",
  limit: "20",
  include: "tax_rates_overview",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/tax-classes?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# Creezi câte o clasă pentru fiecare CATEGORIE de produse pe care o vinzi (bunuri și servicii standard,
# cărți, alimente, cazare, servicii digitale / SaaS, scutite). O clasă este o categorie,
# nu o țară și nu o singură cotă; cotele pe țări stau în interiorul ei.
curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/tax-classes' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "name_lang_map": {
    "en": "Books & publications",
    "ro": "Cărți și publicații"
  },
  "description_lang_map": {
    "en": "Reduced-rate category for books and periodicals."
  }
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// Creezi câte o clasă pentru fiecare CATEGORIE de produse pe care o vinzi (bunuri și servicii standard,
// cărți, alimente, cazare, servicii digitale / SaaS, scutite). O clasă este o categorie,
// nu o țară și nu o singură cotă; cotele pe țări stau în interiorul ei.
const result = await fetch(`${baseUrl}/organizations/${organizationId}/tax-classes`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // categoria, nu o cotă: hărți pe limbi
    name_lang_map: {
      en: "Books & publications",
      ro: "Cărți și publicații",
    },
    description_lang_map: { en: "Reduced-rate category for books and periodicals." },
  }),
}).then((response) => response.json());

# Actualizezi etichetele unei categorii
curl -X PUT 'https://api.enlivy.com/organizations/<organization_id>/tax-classes/<tax_class_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "name_lang_map": {
    "en": "Books & publications (2026)"
  }
}'

# ștergere reversibilă; restaurezi cu POST /tax-classes/restore/{taxClassId}
curl -X DELETE 'https://api.enlivy.com/organizations/<organization_id>/tax-classes/<tax_class_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const taxClassId = "<tax_class_id>";

// Actualizezi etichetele unei categorii
const result1 = await fetch(`${baseUrl}/organizations/${organizationId}/tax-classes/${taxClassId}`, {
  method: "PUT",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    name_lang_map: { en: "Books & publications (2026)" },
  }),
}).then((response) => response.json());

// ștergere reversibilă; restaurezi cu POST /tax-classes/restore/{taxClassId}
const result2 = await fetch(`${baseUrl}/organizations/${organizationId}/tax-classes/${taxClassId}`, {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# includes: organization, organization_tax_class, locations
curl -G 'https://api.enlivy.com/organizations/<organization_id>/tax-rates' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=50' \
  --data-urlencode 'include=organization_tax_class,locations' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// includes: organization, organization_tax_class, locations
const query = new URLSearchParams({
  page: "1",
  limit: "50",
  include: "organization_tax_class,locations",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/tax-rates?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# O cotă de impozitare este UN RÂND din setul de cote al unei clase, nu o taxă de sine stătătoare.
# Fiecare rând declară un domeniu (locații și/sau condiții pentru cumpărător), o categorie TVA EN16931
# (eu_vat_class) și o prioritate. La facturare, Enlivy alege rândul cu cea mai mare prioritate
# al cărui domeniu și cumpărător se potrivesc.
# Setul tipic pentru o categorie (țara de origine = România): patru modele.
#
# Intern, în țara de origine: implicit când vinzi în România
curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/tax-rates' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_tax_class_id": "<standard_goods_class_id>",
  "has_eu_vat_properties": true,
  "is_compound": false,
  "is_inclusive": false,
  "name": "RO Domestic 21%",
  "rate": 21,
  "priority": 1000,
  "eu_vat_class": "S",
  "has_locations": true,
  "locations": [
    {
      "country_code": "RO"
    }
  ]
}'

# Taxare inversă UE B2B: 0%, se aplică DOAR firmelor înregistrate în scopuri de TVA din alte state UE
curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/tax-rates' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_tax_class_id": "<standard_goods_class_id>",
  "has_eu_vat_properties": true,
  "is_compound": false,
  "is_inclusive": false,
  "name": "EU B2B Reverse Charge",
  "rate": 0,
  "priority": 900,
  "eu_vat_class": "AE",
  "vatex_code": "VATEX-EU-AE",
  "is_business_entity": true,
  "is_eu_vat_registered": true,
  "has_locations": true,
  "locations": [
    {
      "country_code": "DE"
    },
    {
      "country_code": "FR"
    }
  ]
}'

# Intern pe țară în UE (B2C digital / OSS): aplici cota țării cumpărătorului
curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/tax-rates' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_tax_class_id": "<standard_goods_class_id>",
  "has_eu_vat_properties": true,
  "is_compound": false,
  "is_inclusive": false,
  "name": "DE Domestic 19%",
  "rate": 19,
  "priority": 800,
  "eu_vat_class": "S",
  "has_locations": true,
  "locations": [
    {
      "country_code": "DE"
    }
  ]
}'

# Restul lumii: în afara domeniului TVA, 0%, fără locații = regula de rezervă
curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/tax-rates' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_tax_class_id": "<standard_goods_class_id>",
  "has_eu_vat_properties": true,
  "is_compound": false,
  "is_inclusive": false,
  "name": "Rest of World (Outside Scope)",
  "rate": 0,
  "priority": 100,
  "eu_vat_class": "O",
  "vatex_code": "VATEX-EU-O",
  "has_locations": false
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const headers = {
  Authorization: `Bearer ${token}`,
  Accept: "application/json",
  "Content-Type": "application/json",
};

// O cotă de impozitare este UN RÂND din setul de cote al unei clase, nu o taxă de sine stătătoare.
// Fiecare rând declară un domeniu (locații și/sau condiții pentru cumpărător), o categorie TVA EN16931
// (eu_vat_class) și o prioritate. La facturare, Enlivy alege rândul cu cea mai mare prioritate
// al cărui domeniu și cumpărător se potrivesc.
// Setul tipic pentru o categorie (țara de origine = România): patru modele.
//
// Intern, în țara de origine: implicit când vinzi în România
const result1 = await fetch(`${baseUrl}/organizations/${organizationId}/tax-rates`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    organization_tax_class_id: "<standard_goods_class_id>",
    has_eu_vat_properties: true,
    is_compound: false,
    is_inclusive: false,
    name: "RO Domestic 21%",
    rate: 21,
    priority: 1000,
    // Cotă standard, trecută pe linia de factură
    eu_vat_class: "S",
    has_locations: true,
    locations: [{ country_code: "RO" }],
  }),
}).then((response) => response.json());

// Taxare inversă UE B2B: 0%, se aplică DOAR firmelor înregistrate în scopuri de TVA din alte state UE
const result2 = await fetch(`${baseUrl}/organizations/${organizationId}/tax-rates`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    organization_tax_class_id: "<standard_goods_class_id>",
    has_eu_vat_properties: true,
    is_compound: false,
    is_inclusive: false,
    name: "EU B2B Reverse Charge",
    rate: 0,
    priority: 900,
    eu_vat_class: "AE",
    // motivul scutirii (PEPPOL)
    vatex_code: "VATEX-EU-AE",
    // condiții pentru cumpărător
    is_business_entity: true,
    is_eu_vat_registered: true,
    has_locations: true,
    locations: [{ country_code: "DE" }, { country_code: "FR" }],
  }),
}).then((response) => response.json());

// Intern pe țară în UE (B2C digital / OSS): aplici cota țării cumpărătorului
const result3 = await fetch(`${baseUrl}/organizations/${organizationId}/tax-rates`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    organization_tax_class_id: "<standard_goods_class_id>",
    has_eu_vat_properties: true,
    is_compound: false,
    is_inclusive: false,
    name: "DE Domestic 19%",
    rate: 19,
    priority: 800,
    eu_vat_class: "S",
    has_locations: true,
    locations: [{ country_code: "DE" }],
  }),
}).then((response) => response.json());

// Restul lumii: în afara domeniului TVA, 0%, fără locații = regula de rezervă
const result4 = await fetch(`${baseUrl}/organizations/${organizationId}/tax-rates`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    organization_tax_class_id: "<standard_goods_class_id>",
    has_eu_vat_properties: true,
    is_compound: false,
    is_inclusive: false,
    name: "Rest of World (Outside Scope)",
    rate: 0,
    priority: 100,
    eu_vat_class: "O",
    vatex_code: "VATEX-EU-O",
    has_locations: false,
  }),
}).then((response) => response.json());

# Modifici un singur rând: procentul, categoria TVA, domeniul sau prioritatea.
# Trimiți doar câmpurile pe care le schimbi.
curl -X PUT 'https://api.enlivy.com/organizations/<organization_id>/tax-rates/<tax_rate_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "rate": 20,
  "display_name": "VAT 20%"
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const taxRateId = "<tax_rate_id>";

// Modifici un singur rând: procentul, categoria TVA, domeniul sau prioritatea.
// Trimiți doar câmpurile pe care le schimbi.
const result = await fetch(`${baseUrl}/organizations/${organizationId}/tax-rates/${taxRateId}`, {
  method: "PUT",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // de exemplu, se schimbă cota internă din RO
    rate: 20,
    display_name: "VAT 20%",
  }),
}).then((response) => response.json());

# ștergere reversibilă; restaurezi cu POST /tax-rates/restore/{taxRateId}
curl -X DELETE 'https://api.enlivy.com/organizations/<organization_id>/tax-rates/<tax_rate_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const taxRateId = "<tax_rate_id>";

// ștergere reversibilă; restaurezi cu POST /tax-rates/restore/{taxRateId}
const result = await fetch(`${baseUrl}/organizations/${organizationId}/tax-rates/${taxRateId}`, {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -G 'https://api.enlivy.com/organizations/<organization_id>/prospects' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=20' \
  --data-urlencode 'source_type=inbound' \
  --data-urlencode 'include=organization_prospect_stage,assigned_organization_user' \
  --data-urlencode 'include_meta=navigation' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const query = new URLSearchParams({
  page: "1",
  limit: "20",
  source_type: "inbound",
  include: "organization_prospect_stage,assigned_organization_user",
  include_meta: "navigation",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/prospects?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -G 'https://api.enlivy.com/organizations/<organization_id>/prospects/<prospect_id>' \
  --data-urlencode 'include=organization_prospect_stage,assigned_organization_user' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const prospectId = "<prospect_id>";

const query = new URLSearchParams({
  include: "organization_prospect_stage,assigned_organization_user",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/prospects/${prospectId}?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/prospects' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "first_name": "Jane",
  "last_name": "Doe",
  "company_name": "Acme Studio",
  "email": "jane@acme.example",
  "source_type": "inbound",
  "source_channel": "website",
  "source_campaign": "summer-launch",
  "summary": "Requested a demo from the pricing page.",
  "budget": "5000",
  "budget_currency": "EUR"
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/prospects`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    first_name: "Jane",
    last_name: "Doe",
    company_name: "Acme Studio",
    email: "jane@acme.example",
    source_type: "inbound",
    source_channel: "website",
    source_campaign: "summer-launch",
    summary: "Requested a demo from the pricing page.",
    budget: "5000",
    budget_currency: "EUR",
  }),
}).then((response) => response.json());

curl -X PUT 'https://api.enlivy.com/organizations/<organization_id>/prospects/<prospect_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "summary": "Budget confirmed, decision expected next week.",
  "budget": "8000",
  "budget_currency": "EUR"
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const prospectId = "<prospect_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/prospects/${prospectId}`, {
  method: "PUT",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    summary: "Budget confirmed, decision expected next week.",
    budget: "8000",
    budget_currency: "EUR",
  }),
}).then((response) => response.json());

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/prospects/<prospect_id>/advance' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_prospect_stage_path_id": "stage_path_id_here",
  "outcome": "Qualified, budget and timeline confirmed.",
  "description": "Moved from New to Qualified after the discovery call."
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const prospectId = "<prospect_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/prospects/${prospectId}/advance`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    organization_prospect_stage_path_id: "stage_path_id_here",
    outcome: "Qualified, budget and timeline confirmed.",
    description: "Moved from New to Qualified after the discovery call.",
  }),
}).then((response) => response.json());

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/prospect-activities' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_prospect_id": "prospect_id_here",
  "title": "Discovery call",
  "description": "Walked through pricing and the onboarding timeline.",
  "outcome": "Positive, sending a proposal next week.",
  "activity_at": "2026-07-03 15:30:00"
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/prospect-activities`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    organization_prospect_id: "prospect_id_here",
    title: "Discovery call",
    description: "Walked through pricing and the onboarding timeline.",
    outcome: "Positive, sending a proposal next week.",
    activity_at: "2026-07-03 15:30:00",
  }),
}).then((response) => response.json());

curl -G 'https://api.enlivy.com/organizations/<organization_id>/prospect-activities' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=20' \
  --data-urlencode 'include=organization_prospect,performed_by_organization_user' \
  --data-urlencode 'include_meta=navigation' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const query = new URLSearchParams({
  page: "1",
  limit: "20",
  include: "organization_prospect,performed_by_organization_user",
  include_meta: "navigation",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/prospect-activities?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# filtrele sunt opționale și se pot combina
# trimiți q=... în loc de ids pentru căutare în tot textul
curl -G 'https://api.enlivy.com/organizations/<organization_id>/contracts' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=20' \
  --data-urlencode 'direction=outbound' \
  --data-urlencode 'category=core' \
  --data-urlencode 'include=contract_status,sender_user,receiver_user,contract_parties' \
  --data-urlencode 'include_meta=navigation' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// filtrele sunt opționale și se pot combina
// trimiți q=... în loc de ids pentru căutare în tot textul
const query = new URLSearchParams({
  page: "1",
  limit: "20",
  direction: "outbound",
  category: "core",
  include: "contract_status,sender_user,receiver_user,contract_parties",
  include_meta: "navigation",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contracts?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# includes disponibile: organization, parent_contract, sender_user, receiver_user,
# file, contract_status, contract_chapters, contract_parties, contract_prefix
curl -G 'https://api.enlivy.com/organizations/<organization_id>/contracts/<contract_id>' \
  --data-urlencode 'include=contract_chapters,contract_parties,contract_status' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractId = "<contract_id>";

// includes disponibile: organization, parent_contract, sender_user, receiver_user,
// file, contract_status, contract_chapters, contract_parties, contract_prefix
const query = new URLSearchParams({
  include: "contract_chapters,contract_parties,contract_status",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contracts/${contractId}?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/contracts' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "category": "core",
  "source": "internal",
  "direction": "outbound",
  "organization_sender_user_id": "<org_user_sender_id>",
  "organization_receiver_user_id": "<org_user_receiver_id>",
  "organization_contract_status_id": "<contract_status_id>",
  "organization_contract_prefix_id": "<contract_prefix_id>",
  "title": "Master Services Agreement",
  "sub_title": "2026 Engagement",
  "locale": "en",
  "issued_at": "2026-07-03 09:00:00",
  "ends_at": "2027-07-03 09:00:00",
  "content_introduction": "This agreement is entered into between the parties below.",
  "content_signature_disclaimer": "By signing, each party agrees to the terms above.",
  "chapters": [
    {
      "title": "Scope of Work",
      "content": "<p>The Provider will deliver…</p>",
      "order": 1
    },
    {
      "title": "Payment Terms",
      "content": "<p>Fees are due within 14 days…</p>",
      "order": 2
    }
  ],
  "parties": [
    {
      "party_type": "organization",
      "party_country_code": "RO",
      "organization_name": "Acme Studio SRL",
      "organization_type": "srl",
      "first_name": "Jane",
      "last_name": "Doe",
      "role_in_organization": "Administrator",
      "referenced_as_within_document": "the Provider",
      "appears_as_party": true,
      "is_signature_required": true,
      "contact_email_address": "jane@acme.example",
      "order": 0
    },
    {
      "party_type": "individual",
      "party_country_code": "RO",
      "first_name": "John",
      "last_name": "Smith",
      "referenced_as_within_document": "the Client",
      "appears_as_party": true,
      "is_signature_required": true,
      "contact_email_address": "john@example.com",
      "order": 1
    }
  ]
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/contracts`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // core | amendment | addenda | supplement.
    // amendment/addenda/supplement CER organization_contract_id -> un contract părinte "core".
    category: "core",
    // internal  -> numerotat automat dintr-un prefix (organization_contract_prefix_id obligatoriu mai jos)
    // uploaded  -> trimiți tu `number` și poți seta `signed_by_all_parties_at`
    source: "internal",
    // outbound | inbound
    direction: "outbound",
    organization_sender_user_id: "<org_user_sender_id>",
    organization_receiver_user_id: "<org_user_receiver_id>",
    organization_contract_status_id: "<contract_status_id>",
    // obligatoriu doar pentru internal + core; îl omiți pentru orice altă sursă sau categorie
    organization_contract_prefix_id: "<contract_prefix_id>",
    title: "Master Services Agreement",
    sub_title: "2026 Engagement",
    locale: "en",
    issued_at: "2026-07-03 09:00:00",
    ends_at: "2027-07-03 09:00:00",
    content_introduction: "This agreement is entered into between the parties below.",
    content_signature_disclaimer: "By signing, each party agrees to the terms above.",
    chapters: [
      {
        title: "Scope of Work",
        content: "<p>The Provider will deliver…</p>",
        order: 1,
      },
      {
        title: "Payment Terms",
        content: "<p>Fees are due within 14 days…</p>",
        order: 2,
      },
    ],
    parties: [
      // se acceptă și blocurile JSON specifice țării, `information` (persoană) și `organization_information`
      // (companie); forma lor e validată după schema țării.
      {
        // party_type, party_country_code, first_name, last_name sunt obligatorii pentru fiecare parte
        // organization | individual
        party_type: "organization",
        party_country_code: "RO",
        // părțile de tip organization CER în plus organization_name + organization_type
        organization_name: "Acme Studio SRL",
        // valoarea vine din datele de referință
        organization_type: "srl",
        first_name: "Jane",
        last_name: "Doe",
        role_in_organization: "Administrator",
        referenced_as_within_document: "the Provider",
        appears_as_party: true,
        is_signature_required: true,
        contact_email_address: "jane@acme.example",
        order: 0,
      },
      {
        party_type: "individual",
        party_country_code: "RO",
        first_name: "John",
        last_name: "Smith",
        referenced_as_within_document: "the Client",
        appears_as_party: true,
        is_signature_required: true,
        contact_email_address: "john@example.com",
        order: 1,
      },
    ],
  }),
}).then((response) => response.json());

curl -X PUT 'https://api.enlivy.com/organizations/<organization_id>/contracts/<contract_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_contract_status_id": "<next_status_id>",
  "sub_title": "2026 Engagement (revised)",
  "ends_at": "2027-12-31 23:59:59"
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractId = "<contract_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/contracts/${contractId}`, {
  method: "PUT",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // actualizare parțială: se modifică doar câmpurile trimise
    organization_contract_status_id: "<next_status_id>",
    sub_title: "2026 Engagement (revised)",
    ends_at: "2027-12-31 23:59:59",
  }),
}).then((response) => response.json());

# primești un fișier: îl citești ca blob, nu ca JSON
curl 'https://api.enlivy.com/organizations/<organization_id>/contracts/<contract_id>/download' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  --remote-name --remote-header-name

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractId = "<contract_id>";

// primești un fișier: îl citești ca blob, nu ca JSON
const pdf = await fetch(`${baseUrl}/organizations/${organizationId}/contracts/${contractId}/download`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
  },
}).then((response) => response.blob());

# ștergere reversibilă; restaurezi cu POST /contracts/restore/{contractId}
curl -X DELETE 'https://api.enlivy.com/organizations/<organization_id>/contracts/<contract_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractId = "<contract_id>";

// ștergere reversibilă; restaurezi cu POST /contracts/restore/{contractId}
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contracts/${contractId}`, {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -G 'https://api.enlivy.com/organizations/<organization_id>/contract-statuses' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=50' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const query = new URLSearchParams({
  page: "1",
  limit: "50",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contract-statuses?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/contract-statuses' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "title_lang_map": {
    "en": "Awaiting Signature",
    "ro": "În așteptarea semnării"
  },
  "description_lang_map": {
    "en": "Sent to all parties for signing.",
    "ro": "Trimis către toate părțile pentru semnare."
  },
  "contract_state": "action_required",
  "direction": "any",
  "order": 3,
  "rgba_color_code": "rgba(59, 130, 246, 1)"
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/contract-statuses`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // hărți pe limbi, nu texte simple
    title_lang_map: {
      en: "Awaiting Signature",
      ro: "În așteptarea semnării",
    },
    description_lang_map: {
      en: "Sent to all parties for signing.",
      ro: "Trimis către toate părțile pentru semnare.",
    },
    // draft | action_required | accepted | breach | terminated
    contract_state: "action_required",
    // inbound | outbound | any
    direction: "any",
    // order este unic în organizație: alegi un loc liber
    // sau reordonezi etapele existente cu PUT /contract-statuses/reorder
    order: 3,
    rgba_color_code: "rgba(59, 130, 246, 1)",
  }),
}).then((response) => response.json());

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/contract-signatures' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_contract_id": "<contract_id>",
  "organization_contract_party_id": "<party_id>",
  "signature_source": "user_flow",
  "sign_session_signature_types": [
    "draw",
    "checkbox"
  ],
  "sign_session_required_confirmations": [
    "email",
    "legally_binding"
  ],
  "expires_at": "2026-07-17 23:59:59"
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/contract-signatures`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    organization_contract_id: "<contract_id>",
    // o singură sesiune activă pe parte; organization_contract_party_id este unic
    organization_contract_party_id: "<party_id>",
    // user_flow   -> Enlivy găzduiește semnarea (linkul vine din sign_session_url)
    // admin_panel -> înregistrezi tu semnătura și poți trimite is_signed / signature_drawing / signed_contract
    signature_source: "user_flow",
    sign_session_signature_types: [
      "draw",
      // draw | checkbox | file_classic | file_electronic
      "checkbox",
    ],
    sign_session_required_confirmations: [
      "email",
      // email | phone | legally_binding
      "legally_binding",
    ],
    expires_at: "2026-07-17 23:59:59",
  }),
}).then((response) => response.json());

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/contract-signatures/<contract_signature_id>/send' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "method": "email",
  "message": "Please review and sign the agreement by Friday."
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractSignatureId = "<contract_signature_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/contract-signatures/${contractSignatureId}/send`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // email | sms
    method: "email",
    message: "Please review and sign the agreement by Friday.",
  }),
}).then((response) => response.json());

# sign_session_url întoarce linkul găzduit pe care îl dai semnatarului.
# status este unul dintre: pending | sent | completed | expired | void
curl -G 'https://api.enlivy.com/organizations/<organization_id>/contract-signatures/<contract_signature_id>' \
  --data-urlencode 'include=sign_session_url,organization_contract' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractSignatureId = "<contract_signature_id>";

// sign_session_url întoarce linkul găzduit pe care îl dai semnatarului.
// status este unul dintre: pending | sent | completed | expired | void
const query = new URLSearchParams({
  include: "sign_session_url,organization_contract",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contract-signatures/${contractSignatureId}?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# omiți organization_contract_id ca să vezi sesiunile tuturor contractelor
curl -G 'https://api.enlivy.com/organizations/<organization_id>/contract-signatures' \
  --data-urlencode 'organization_contract_id=<contract_id>' \
  --data-urlencode 'include=sign_session_url' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// omiți organization_contract_id ca să vezi sesiunile tuturor contractelor
const query = new URLSearchParams({
  organization_contract_id: "<contract_id>",
  include: "sign_session_url",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contract-signatures?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# disponibil și pe fiecare sesiune: /contract-signatures/{signatureId}/download-evidence
curl 'https://api.enlivy.com/organizations/<organization_id>/contracts/<contract_id>/download-evidence' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  --remote-name --remote-header-name

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractId = "<contract_id>";

// disponibil și pe fiecare sesiune: /contract-signatures/{signatureId}/download-evidence
const evidence = await fetch(`${baseUrl}/organizations/${organizationId}/contracts/${contractId}/download-evidence`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
  },
}).then((response) => response.blob());

# filtre: name, description, ids (sau q=... pentru căutare în tot textul)
# includes: organization, tax_class, tag_ids, deleted_by_user
curl -G 'https://api.enlivy.com/organizations/<organization_id>/products' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=20' \
  --data-urlencode 'name=Consulting' \
  --data-urlencode 'include=tax_class' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// filtre: name, description, ids (sau q=... pentru căutare în tot textul)
// includes: organization, tax_class, tag_ids, deleted_by_user
const query = new URLSearchParams({
  page: "1",
  limit: "20",
  name: "Consulting",
  include: "tax_class",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/products?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/products' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "type": "service",
  "price_map": {
    "EUR": "49.90",
    "USD": "54.00"
  },
  "primary_currency": "EUR",
  "name_lang_map": {
    "en": "Consulting Hour",
    "ro": "Oră de consultanță"
  },
  "unit_code": "HUR",
  "description_lang_map": {
    "en": "One hour of advisory services."
  },
  "alias": "consulting-hour",
  "organization_tax_class_id": "<tax_class_id>",
  "is_sold": true,
  "invoice_schema_map": {
    "classification_identifier_cpv": "79411000-8",
    "peppol_billing_unit_code": "HUR"
  },
  "ean_number": null,
  "upc_number": null,
  "stripe_product_id_list": [
    "prod_XXXXXXXX"
  ]
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/products`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // obligatoriu: digital | physical | service | bonus
    type: "service",
    // obligatoriu: o hartă { monedă: sumă } (sume cu cel mult 2 zecimale).
    // Cu 2 sau mai multe monede, primary_currency devine obligatoriu.
    price_map: {
      EUR: "49.90",
      USD: "54.00",
    },
    primary_currency: "EUR",
    // hărți pe limbi (nu texte simple)
    name_lang_map: {
      en: "Consulting Hour",
      ro: "Oră de consultanță",
    },
    // codul de unitate Peppol, 3 caractere: HUR pentru oră, H87 pentru bucată
    unit_code: "HUR",
    description_lang_map: { en: "One hour of advisory services." },
    // opțional; unic în organizație (litere, cifre, cratime)
    alias: "consulting-hour",
    organization_tax_class_id: "<tax_class_id>",
    // dacă produsul se vinde acum
    is_sold: true,
    // metadate opționale pentru e-factură (folosite când produsul ajunge pe o linie de factură)
    invoice_schema_map: {
      // cod CPV
      classification_identifier_cpv: "79411000-8",
      // cod de unitate PEPPOL
      peppol_billing_unit_code: "HUR",
    },
    // identificatori opționali
    ean_number: null,
    upc_number: null,
    stripe_product_id_list: [
      // fiecare id trebuie să înceapă cu "prod_"
      "prod_XXXXXXXX",
    ],
  }),
}).then((response) => response.json());

curl -X PUT 'https://api.enlivy.com/organizations/<organization_id>/products/<product_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "price_map": {
    "EUR": "59.90",
    "USD": "64.00"
  },
  "primary_currency": "EUR",
  "name_lang_map": {
    "en": "Consulting Hour, Senior"
  },
  "is_sold": false
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const productId = "<product_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/products/${productId}`, {
  method: "PUT",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // preț nou: price_map îl înlocuiește pe cel salvat
    price_map: {
      EUR: "59.90",
      USD: "64.00",
    },
    primary_currency: "EUR",
    name_lang_map: { en: "Consulting Hour, Senior" },
    is_sold: false,
  }),
}).then((response) => response.json());

# ștergere reversibilă; restaurezi cu POST /products/restore/{productId}
curl -X DELETE 'https://api.enlivy.com/organizations/<organization_id>/products/<product_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const productId = "<product_id>";

// ștergere reversibilă; restaurezi cu POST /products/restore/{productId}
const result = await fetch(`${baseUrl}/organizations/${organizationId}/products/${productId}`, {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

# filtre: email, created_at_from/to, updated_at_from/to, ids, sau q=... pentru căutare în text
curl -G 'https://api.enlivy.com/organizations/<organization_id>/users' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=20' \
  --data-urlencode 'email=jane@acme.example' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// filtre: email, created_at_from/to, updated_at_from/to, ids, sau q=... pentru căutare în text
const query = new URLSearchParams({
  page: "1",
  limit: "20",
  email: "jane@acme.example",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/users?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/user-client-portal-sessions' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "organization_user_id": "<org_user_id>",
  "name": "Jane Doe",
  "authentication_method": "email",
  "permissions": [
    "invoices",
    "receipts",
    "payment_methods"
  ],
  "validity_hours": 72
}'

# Răspunsul conține: token, status, magic_authentication_url (pentru magic_authentication),
# authentication_verification_code (pentru email / phone), permissions, expires_at.

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/user-client-portal-sessions`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // indici exact identitatea utilizatorului
    organization_user_id: "<org_user_id>",
    // obligatoriu: numele afișat pentru sesiune
    name: "Jane Doe",
    // cum își confirmă utilizatorul identitatea: email | phone | magic_authentication
    authentication_method: "email",
    // ce poate accesa sesiunea în portal
    // opțiuni: invoices | receipts | network_exchanges | contracts | reports | payment_methods
    permissions: [
      "invoices",
      "receipts",
      "payment_methods",
    ],
    // durata: setezi validity_hours SAU expires_at (limitate de maximul serverului)
    validity_hours: 72,
  }),
}).then((response) => response.json());

// Răspunsul conține: token, status, magic_authentication_url (pentru magic_authentication),
// authentication_verification_code (pentru email / phone), permissions, expires_at.

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/user-client-portal-sessions' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "email": "jane@acme.example",
  "name": "Jane Doe",
  "authentication_method": "email",
  "permissions": [
    "invoices",
    "receipts",
    "payment_methods"
  ],
  "validity_hours": 72
}'

# O singură potrivire  -> sesiunea trece la autentificare.
# Mai multe potriviri -> status "awaiting_user_selection"; utilizatorul alege în portal
#                        identitatea cu care se autentifică, apoi continuă.

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/user-client-portal-sessions`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // indici utilizatorul prin email
    email: "jane@acme.example",
    // obligatoriu: numele afișat pentru sesiune
    name: "Jane Doe",
    // cum își confirmă utilizatorul identitatea: email | phone | magic_authentication
    authentication_method: "email",
    // ce poate accesa sesiunea în portal
    // opțiuni: invoices | receipts | network_exchanges | contracts | reports | payment_methods
    permissions: [
      "invoices",
      "receipts",
      "payment_methods",
    ],
    // durata: setezi validity_hours SAU expires_at (limitate de maximul serverului)
    validity_hours: 72,
  }),
}).then((response) => response.json());

// O singură potrivire  -> sesiunea trece la autentificare.
// Mai multe potriviri -> status "awaiting_user_selection"; utilizatorul alege în portal
//                        identitatea cu care se autentifică, apoi continuă.

# includes: organization_user, organization
curl -G 'https://api.enlivy.com/organizations/<organization_id>/user-client-portal-sessions/<user_client_portal_session_id>' \
  --data-urlencode 'include=organization_user' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

# status: pending | email_verification_sent | awaiting_user_selection | success | expired

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const userClientPortalSessionId = "<user_client_portal_session_id>";

// includes: organization_user, organization
const query = new URLSearchParams({
  include: "organization_user",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/user-client-portal-sessions/${userClientPortalSessionId}?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

// status: pending | email_verification_sent | awaiting_user_selection | success | expired