easycontract 0.1.4__tar.gz → 0.1.7__tar.gz

{easycontract-0.1.4 → easycontract-0.1.7}/CHANGELOG.md

@@ -2,6 +2,84 @@
 
 All notable changes to the `easycontract` Python SDK.
 
+## 0.1.7 (2026-11-10)
+
+**Features**
+
+- Template versioning: envelopes are created from the latest APPROVED
+  version of a template, never from its draft.
+  `client.templates.list_versions/approve_version/get_version`;
+  `create_envelope` on a template with no approved version raises the
+  `template_not_approved` error (409). Templates and envelopes carry the
+  version (`current_version`, `envelope["template"]["version"]`).
+- `client.templates.update_role` (a new key rewrites the role's tokens in
+  the documents; `adopt_tokens_of` gives a role the tokens of a key no role
+  has, listed in the template's `unknown_roles` with `expand=roles`) and
+  `client.templates.delete_role`.
+- `client.templates.set_margin_image` / `delete_margin_image`: a logo or
+  seal in the header or footer of an authored document (PNG, JPEG or WebP,
+  2 MB at most; `align` start, center or end). A new image is checked at
+  once (400 if refused), then waits for the malware scan before it is
+  published: the template document carries `header_image` /
+  `footer_image` (the published one: type, size, SHA-256, place) and
+  `header_image_upload` / `footer_image_upload` (one still in the scan, or
+  refused).
+- `client.templates.preview(technical=True)`: the technical view of the
+  template draft (every fillable field explained, highlighted in the
+  documents with example values and how the API passes each one).
+- `client.templates.compare_versions` (what changed between two versions,
+  or a version and the draft) and `client.templates.restore_version` (copy
+  an earlier version into the draft; approving it makes a new version).
+- `client.organization.group()`: the organization group (Enterprise,
+  read only), its members and the invitations received; `features` gains
+  `organization_groups`. `client.organization.group_templates()` and
+  `copy_group_template()`: templates the other organizations of the group
+  offer, copied as a draft of your own; `templates.update(group_shared=...)`
+  offers one, and templates carry `group_shared` and `copied_from`.
+  A copy follows its source: `client.templates.upstream()` (newer approved
+  version?), `compare_upstream()` and `pull_upstream()` (into the draft);
+  `templates.update(follow_updates=...)` switches the e-mail notices.
+- Attention points in other languages: `client.templates.list_attention_translations`,
+  `get_attention_translation`, `set_attention_translation` (drafts),
+  `delete_attention_translation` and `autotranslate_attention_points` (a
+  machine draft; a document's autotranslation drafts them too). Template
+  points carry `translations` (status per language), translation jobs
+  carry `scope`, and the version comparison `attention_point_translations`.
+  A template is usable in a language only when its attention points are
+  approved in it too (approval stays in the panel).
+- `templates.request_countersign_authorization(scope=...)`: `"version"`
+  (default) or `"future_versions"` (the authorization also covers the
+  versions approved later). Authorizations carry `template_version` and
+  `scope`.
+
+## 0.1.6 (2026-11-08)
+
+**Features**
+
+- Attention points: parts of the contract the signer must notice, shown on
+  the signing page before the documents (never stamped in the PDF).
+  `client.templates.list_attention_points/add_attention_point/
+  update_attention_point/delete_attention_point` (the defaults of every
+  envelope created from the template) and the same four on
+  `client.envelopes` (draft envelopes; on one created from a template, Pro
+  and Enterprise). `requires_ack=True` makes the signer confirm it before
+  signing. `templates.create_envelope(attention_points=[…])` replaces the
+  template's for that envelope only (Pro and Enterprise).
+
+## 0.1.5 (2026-10-23)
+
+**Features**
+
+- Automatic countersignature of the organization (Pro+):
+  `client.templates.request_countersign_authorization(template_id,
+  authorizer_email=…, authorizer_title=…, valid_until="YYYY-MM-DD",
+  max_uses=None, variables={…})` (the authorizer signs it by e-mail),
+  `client.templates.list_countersign_authorizations`,
+  `client.countersign_authorizations.list/get/revoke`,
+  `client.envelopes.retry_countersign` and
+  `client.envelopes.skip_countersign(reason=…)`. `templates.create_envelope`
+  accepts `countersign="none"`; envelopes carry `countersign`.
+
 ## 0.1.4 (2026-10-20)
 
 **Features**

{easycontract-0.1.4 → easycontract-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: easycontract
-Version: 0.1.4
+Version: 0.1.7
 Summary: SDK oficial de Python para el API de easycontract (firma electrónica eIDAS)
 Project-URL: Documentation, https://easycontract.online/docs/api
 Author-email: Román Ramírez <roman@easycontract.online>

{easycontract-0.1.4 → easycontract-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "easycontract"
-version = "0.1.4"
+version = "0.1.7"
 description = "SDK oficial de Python para el API de easycontract (firma electrónica eIDAS)"
 readme = "README.md"
 requires-python = ">=3.10"

{easycontract-0.1.4 → easycontract-0.1.7}/src/easycontract/__init__.py

@@ -6,7 +6,7 @@ client = EasyContract(api_key="ec_test_...")
 envelope = client.envelopes.create(title="Contrato", retention_period_months=72)
 """
 
-__version__ = "0.1.4"
+__version__ = "0.1.7"
 
 from . import webhooks
 from .client import EasyContract

{easycontract-0.1.4 → easycontract-0.1.7}/src/easycontract/client.py

@@ -23,6 +23,7 @@ import requests
 from . import __version__
 from .errors import APIError, error_from_response
 from .resources import (
+    CountersignAuthorizations,
     Envelopes,
     Events,
     Identity,
@@ -109,6 +110,7 @@ class EasyContract:
         self.identity = Identity(self)
         self.retention = Retention(self)
         self.templates = Templates(self)
+        self.countersign_authorizations = CountersignAuthorizations(self)
         self.webhooks = Webhooks(self)
         self.projects = Projects(self)
         self.events = Events(self)

{easycontract-0.1.4 → easycontract-0.1.7}/src/easycontract/resources.py

@@ -14,6 +14,15 @@ from urllib.parse import quote
 from .errors import EasyContractError
 
 
+def _attention_body(title, body, document_id, page, requires_ack) -> dict:
+    payload: dict = {"title": title, "body": body, "requires_ack": requires_ack}
+    if document_id is not None:
+        payload["document_id"] = document_id
+    if page is not None:
+        payload["page"] = page
+    return payload
+
+
 def _id(value) -> str:
     """A resource identifier as a path segment: it must be a UUID (every
     resource id of the API is). Anything else — "../webhooks/x", "a?b",
@@ -38,6 +47,12 @@ def _seg(value) -> str:
 OPERATIONS: dict[tuple[str, str], str] = {
     ("GET", "/whoami/"): "client.whoami",
     ("GET", "/organization/"): "client.organization.get",
+    ("GET", "/organization/group/"): "client.organization.group",
+    ("GET", "/organization/group/templates/"): "client.organization.group_templates",
+    (
+        "POST",
+        "/organization/group/templates/{template_id}/copy/",
+    ): "client.organization.copy_group_template",
     ("GET", "/members/"): "client.members.list",
     ("PATCH", "/members/{membership_id}/"): "client.members.change_role",
     ("DELETE", "/members/{membership_id}/"): "client.members.remove",
@@ -59,6 +74,31 @@ OPERATIONS: dict[tuple[str, str], str] = {
         "/envelopes/{envelope_id}/signers/{signer_id}/embedded-session/",
     ): "client.envelopes.create_embedded_session",
     ("POST", "/envelopes/{envelope_id}/void/"): "client.envelopes.void",
+    (
+        "POST",
+        "/envelopes/{envelope_id}/countersign/retry/",
+    ): "client.envelopes.retry_countersign",
+    (
+        "POST",
+        "/envelopes/{envelope_id}/countersign/skip/",
+    ): "client.envelopes.skip_countersign",
+    ("GET", "/countersign-authorizations/"): "client.countersign_authorizations.list",
+    (
+        "GET",
+        "/countersign-authorizations/{authorization_id}/",
+    ): "client.countersign_authorizations.get",
+    (
+        "POST",
+        "/countersign-authorizations/{authorization_id}/revoke/",
+    ): "client.countersign_authorizations.revoke",
+    (
+        "GET",
+        "/templates/{template_id}/countersign-authorizations/",
+    ): "client.templates.list_countersign_authorizations",
+    (
+        "POST",
+        "/templates/{template_id}/countersign-authorizations/",
+    ): "client.templates.request_countersign_authorization",
     ("GET", "/envelopes/{envelope_id}/certificate/"): "client.envelopes.download_certificate",
     (
         "POST",
@@ -141,9 +181,85 @@ OPERATIONS: dict[tuple[str, str], str] = {
     ): "client.templates.autotranslate",
     ("GET", "/translation-jobs/{job_id}/"): "client.templates.get_translation_job",
     ("POST", "/templates/{template_id}/preview/"): "client.templates.preview",
+    (
+        "POST",
+        "/templates/{template_id}/documents/{document_id}/margin-images/{slot}/",
+    ): "client.templates.set_margin_image",
+    (
+        "DELETE",
+        "/templates/{template_id}/documents/{document_id}/margin-images/{slot}/",
+    ): "client.templates.delete_margin_image",
     ("POST", "/templates/{template_id}/duplicate/"): "client.templates.duplicate",
     ("POST", "/templates/{template_id}/roles/"): "client.templates.add_role",
+    ("PATCH", "/templates/{template_id}/roles/{role_id}/"): "client.templates.update_role",
+    ("DELETE", "/templates/{template_id}/roles/{role_id}/"): "client.templates.delete_role",
+    ("GET", "/templates/{template_id}/versions/"): "client.templates.list_versions",
+    ("POST", "/templates/{template_id}/versions/"): "client.templates.approve_version",
+    ("GET", "/templates/{template_id}/versions/{number}/"): "client.templates.get_version",
+    ("GET", "/templates/{template_id}/versions/compare/"): "client.templates.compare_versions",
+    (
+        "POST",
+        "/templates/{template_id}/versions/{number}/restore/",
+    ): "client.templates.restore_version",
     ("POST", "/templates/{template_id}/fields/"): "client.templates.add_field",
+    ("GET", "/templates/{template_id}/upstream/"): "client.templates.upstream",
+    (
+        "GET",
+        "/templates/{template_id}/upstream/compare/",
+    ): "client.templates.compare_upstream",
+    ("POST", "/templates/{template_id}/upstream/pull/"): "client.templates.pull_upstream",
+    (
+        "GET",
+        "/templates/{template_id}/attention-points/",
+    ): "client.templates.list_attention_points",
+    (
+        "POST",
+        "/templates/{template_id}/attention-points/",
+    ): "client.templates.add_attention_point",
+    (
+        "PATCH",
+        "/templates/{template_id}/attention-points/{point_id}/",
+    ): "client.templates.update_attention_point",
+    (
+        "DELETE",
+        "/templates/{template_id}/attention-points/{point_id}/",
+    ): "client.templates.delete_attention_point",
+    (
+        "GET",
+        "/templates/{template_id}/attention-points/translations/",
+    ): "client.templates.list_attention_translations",
+    (
+        "GET",
+        "/templates/{template_id}/attention-points/translations/{language}/",
+    ): "client.templates.get_attention_translation",
+    (
+        "PUT",
+        "/templates/{template_id}/attention-points/translations/{language}/",
+    ): "client.templates.set_attention_translation",
+    (
+        "DELETE",
+        "/templates/{template_id}/attention-points/translations/{language}/",
+    ): "client.templates.delete_attention_translation",
+    (
+        "POST",
+        "/templates/{template_id}/attention-points/translations/{language}/autotranslate/",
+    ): "client.templates.autotranslate_attention_points",
+    (
+        "GET",
+        "/envelopes/{envelope_id}/attention-points/",
+    ): "client.envelopes.list_attention_points",
+    (
+        "POST",
+        "/envelopes/{envelope_id}/attention-points/",
+    ): "client.envelopes.add_attention_point",
+    (
+        "PATCH",
+        "/envelopes/{envelope_id}/attention-points/{point_id}/",
+    ): "client.envelopes.update_attention_point",
+    (
+        "DELETE",
+        "/envelopes/{envelope_id}/attention-points/{point_id}/",
+    ): "client.envelopes.delete_attention_point",
     ("POST", "/templates/{template_id}/envelopes/"): "client.templates.create_envelope",
     ("GET", "/events/"): "client.events.list",
     ("GET", "/webhooks/"): "client.webhooks.list",
@@ -173,6 +289,36 @@ def _file_tuple(file, name: str | None, content_type: str = "application/pdf"):
     return (name or getattr(file, "name", "document.pdf"), file, content_type)
 
 
+def _image_mime(file, name: str | None) -> str:
+    """Content type of an image upload, from its first bytes when it can be
+    read without consuming it, else from the file name (the server decides
+    anyway: it decodes and re-encodes every image)."""
+    head = b""
+    if isinstance(file, bytes):
+        head = file[:12]
+    elif isinstance(file, (str, Path)):
+        with Path(file).open("rb") as fh:
+            head = fh.read(12)
+    if head.startswith(b"\x89PNG"):
+        return "image/png"
+    if head.startswith(b"\xff\xd8"):
+        return "image/jpeg"
+    if head[:4] == b"RIFF" and head[8:12] == b"WEBP":
+        return "image/webp"
+    if name:
+        label = name
+    elif isinstance(file, (str, Path)):
+        label = str(file)
+    else:
+        label = str(getattr(file, "name", "") or "")
+    lower = label.lower()
+    if lower.endswith((".jpg", ".jpeg")):
+        return "image/jpeg"
+    if lower.endswith(".webp"):
+        return "image/webp"
+    return "image/png"
+
+
 class _Resource:
     def __init__(self, client):
         self._client = client
@@ -372,11 +518,64 @@ class Envelopes(_Resource):
     def release_legal_hold(self, envelope_id: str) -> dict:
         return self._client.request("DELETE", f"/envelopes/{_id(envelope_id)}/legal-hold/")
 
+    def list_attention_points(self, envelope_id: str) -> dict:
+        """Attention points shown to the signers before the documents, with
+        who confirmed each one."""
+        return self._client.request("GET", f"/envelopes/{_id(envelope_id)}/attention-points/")
+
+    def add_attention_point(
+        self,
+        envelope_id: str,
+        *,
+        title: str,
+        body: str = "",
+        document_id: str | None = None,
+        page: int | None = None,
+        requires_ack: bool = False,
+        idempotency_key: str | None = None,
+    ) -> dict:
+        """Draft envelopes only. On an envelope created from a template it is
+        Pro and Enterprise (403 feature_not_available otherwise)."""
+        return self._client.request(
+            "POST",
+            f"/envelopes/{_id(envelope_id)}/attention-points/",
+            json=_attention_body(title, body, document_id, page, requires_ack),
+            idempotency_key=idempotency_key,
+        )
+
+    def update_attention_point(self, envelope_id: str, point_id: str, **changes) -> dict:
+        """title, body, document_id, page, requires_ack (drafts only)."""
+        return self._client.request(
+            "PATCH",
+            f"/envelopes/{_id(envelope_id)}/attention-points/{_id(point_id)}/",
+            json=changes,
+        )
+
+    def delete_attention_point(self, envelope_id: str, point_id: str):
+        return self._client.request(
+            "DELETE", f"/envelopes/{_id(envelope_id)}/attention-points/{_id(point_id)}/"
+        )
+
     def void(self, envelope_id: str, *, reason: str = "") -> dict:
         return self._client.request(
             "POST", f"/envelopes/{_id(envelope_id)}/void/", json={"reason": reason}
         )
 
+    def retry_countersign(self, envelope_id: str) -> dict:
+        """Signed by everybody and waiting (countersign.status == "failed"):
+        try the organization's countersignature again, e.g. after a new
+        authorization was signed."""
+        return self._client.request("POST", f"/envelopes/{_id(envelope_id)}/countersign/retry/")
+
+    def skip_countersign(self, envelope_id: str, *, reason: str) -> dict:
+        """Complete it WITHOUT the organization's countersignature (the
+        reason is required and stated in the certificate)."""
+        return self._client.request(
+            "POST",
+            f"/envelopes/{_id(envelope_id)}/countersign/skip/",
+            json={"reason": reason},
+        )
+
     def download_certificate(self, envelope_id: str, *, to: str | Path | None = None) -> bytes:
         content = self._client.request(
             "GET", f"/envelopes/{_id(envelope_id)}/certificate/", raw=True
@@ -475,7 +674,9 @@ class Templates(_Resource):
 
     def update(self, template_id: str, **changes) -> dict:
         """PATCH settings: name, description, signing_order,
-        retention_period_months, variables (schema list), metadata."""
+        retention_period_months, variables (schema list), metadata,
+        group_shared (offer it to the organization group), follow_updates
+        (a group copy: notices of the source's new versions)."""
         return self._client.request("PATCH", f"/templates/{_id(template_id)}/", json=changes)
 
     def catalog(self, *, language: str | None = None) -> dict:
@@ -653,6 +854,47 @@ class Templates(_Resource):
             data={"name": name} if name else None,
         )
 
+    def set_margin_image(
+        self,
+        template_id: str,
+        document_id: str,
+        slot: str,
+        *,
+        file=None,
+        align: str | None = None,
+        name: str | None = None,
+    ) -> dict:
+        """Put, replace or move the image of the ``slot`` margin (``"header"``
+        or ``"footer"``) of an authored document of the template draft: a
+        PNG, JPEG or WebP of 2 MB at most (``file``: path, bytes or file
+        object) and/or ``align`` (``"start"``, ``"center"``, ``"end"``).
+        A new image is published after its malware scan (see
+        ``header_image_upload`` / ``footer_image_upload`` in the returned
+        document); approving a new version then puts it in new envelopes."""
+        if slot not in ("header", "footer"):
+            raise ValueError("slot must be 'header' or 'footer'")
+        path = f"/templates/{_id(template_id)}/documents/{_id(document_id)}/margin-images/{slot}/"
+        if file is None:
+            if align is None:
+                raise ValueError("give file, align or both")
+            return self._client.request("POST", path, json={"align": align})
+        mime = _image_mime(file, name)
+        return self._client.request(
+            "POST",
+            path,
+            files={"file": _file_tuple(file, name or f"{slot}.{mime.split('/')[1]}", mime)},
+            data={"align": align} if align else None,
+        )
+
+    def delete_margin_image(self, template_id: str, document_id: str, slot: str) -> dict:
+        """Remove the image of the ``slot`` margin (``"header"`` or ``"footer"``)."""
+        if slot not in ("header", "footer"):
+            raise ValueError("slot must be 'header' or 'footer'")
+        return self._client.request(
+            "DELETE",
+            f"/templates/{_id(template_id)}/documents/{_id(document_id)}/margin-images/{slot}/",
+        )
+
     def preview(
         self,
         template_id: str,
@@ -662,11 +904,16 @@ class Templates(_Resource):
         signers: dict[str, dict] | None = None,
         title: str = "",
         language: str | None = None,
+        technical: bool = False,
         to: str | Path | None = None,
     ) -> bytes:
         """PDF preview of the authored documents (sample values where
-        none are given). Nothing is persisted."""
+        none are given). ``technical=True``: the technical view of the
+        draft instead (every fillable field explained, with examples and
+        how the API passes each one). Nothing is persisted."""
         body: dict = {"variables": variables or {}, "signers": signers or {}, "title": title}
+        if technical:
+            body["technical"] = True
         if document_id:
             body["document_id"] = document_id
         if language:
@@ -719,6 +966,186 @@ class Templates(_Resource):
             body["auth_methods"] = auth_methods
         return self._client.request("POST", f"/templates/{_id(template_id)}/roles/", json=body)
 
+    def update_role(
+        self,
+        template_id: str,
+        role_id: str,
+        *,
+        key: str | None = None,
+        label: str | None = None,
+        order: int | None = None,
+        auth_methods: list[str] | None = None,
+        adopt_tokens_of: str | None = None,
+    ) -> dict:
+        """Edit a role of the template draft. A new ``key`` rewrites the
+        role's tokens in every authored document and translation (changed
+        translations go back to draft); ``adopt_tokens_of`` gives the role
+        the tokens of a key no role has (``unknown_roles`` of the template
+        with ``expand=roles``); ``renamed_in`` says where."""
+        body: dict = {}
+        for name, value in (
+            ("key", key),
+            ("label", label),
+            ("order", order),
+            ("auth_methods", auth_methods),
+            ("adopt_tokens_of", adopt_tokens_of),
+        ):
+            if value is not None:
+                body[name] = value
+        return self._client.request(
+            "PATCH", f"/templates/{_id(template_id)}/roles/{_id(role_id)}/", json=body
+        )
+
+    def delete_role(self, template_id: str, role_id: str) -> None:
+        """Remove a role from the draft (refused while a document uses its tokens)."""
+        self._client.request("DELETE", f"/templates/{_id(template_id)}/roles/{_id(role_id)}/")
+
+    def list_versions(self, template_id: str) -> dict:
+        """Approved versions kept, newest first, plus ``current_version`` and
+        ``has_unapproved_changes`` (the draft differs from the version in use)."""
+        return self._client.request("GET", f"/templates/{_id(template_id)}/versions/")
+
+    def approve_version(
+        self, template_id: str, *, note: str = "", idempotency_key: str | None = None
+    ) -> dict:
+        """Approve the draft as the next version: envelopes created from now
+        on use it. Raises on 409 ``template_unchanged`` when nothing changed."""
+        return self._client.request(
+            "POST",
+            f"/templates/{_id(template_id)}/versions/",
+            json={"note": note} if note else {},
+            idempotency_key=idempotency_key,
+        )
+
+    def compare_versions(
+        self, template_id: str, *, from_: int | str | None = None, to: int | str = "draft"
+    ) -> dict:
+        """What changed from ``from_`` to ``to`` (a version number or
+        ``"draft"``). Default: from the version in use to the draft."""
+        params: dict = {"to": str(to)}
+        if from_ is not None:
+            params["from"] = str(from_)
+        return self._client.request(
+            "GET", f"/templates/{_id(template_id)}/versions/compare/", params=params
+        )
+
+    def restore_version(
+        self, template_id: str, number: int, *, idempotency_key: str | None = None
+    ) -> dict:
+        """Copy version ``number`` into the draft (unapproved draft work is
+        lost). Approve the draft afterwards: it becomes a new version."""
+        return self._client.request(
+            "POST",
+            f"/templates/{_id(template_id)}/versions/{int(number)}/restore/",
+            idempotency_key=idempotency_key,
+        )
+
+    def get_version(self, template_id: str, number: int) -> dict:
+        return self._client.request("GET", f"/templates/{_id(template_id)}/versions/{int(number)}/")
+
+    def list_attention_points(self, template_id: str) -> dict:
+        return self._client.request("GET", f"/templates/{_id(template_id)}/attention-points/")
+
+    def add_attention_point(
+        self,
+        template_id: str,
+        *,
+        title: str,
+        body: str = "",
+        document_id: str | None = None,
+        page: int | None = None,
+        requires_ack: bool = False,
+        idempotency_key: str | None = None,
+    ) -> dict:
+        """Default attention point of every envelope created from the template."""
+        return self._client.request(
+            "POST",
+            f"/templates/{_id(template_id)}/attention-points/",
+            json=_attention_body(title, body, document_id, page, requires_ack),
+            idempotency_key=idempotency_key,
+        )
+
+    def update_attention_point(self, template_id: str, point_id: str, **changes) -> dict:
+        """title, body, document_id, page, requires_ack."""
+        return self._client.request(
+            "PATCH",
+            f"/templates/{_id(template_id)}/attention-points/{_id(point_id)}/",
+            json=changes,
+        )
+
+    def delete_attention_point(self, template_id: str, point_id: str):
+        return self._client.request(
+            "DELETE", f"/templates/{_id(template_id)}/attention-points/{_id(point_id)}/"
+        )
+
+    def upstream(self, template_id: str) -> dict:
+        """A copy of a group template: its source and whether it has a newer
+        approved version (`update_available`)."""
+        return self._client.request("GET", f"/templates/{_id(template_id)}/upstream/")
+
+    def compare_upstream(self, template_id: str) -> dict:
+        """What pulling the source's latest approved version would change."""
+        return self._client.request("GET", f"/templates/{_id(template_id)}/upstream/compare/")
+
+    def pull_upstream(self, template_id: str, *, idempotency_key: str | None = None) -> dict:
+        """The source's latest approved version replaces the copy's draft
+        (translations as drafts); approve the draft to use it."""
+        return self._client.request(
+            "POST",
+            f"/templates/{_id(template_id)}/upstream/pull/",
+            json={},
+            idempotency_key=idempotency_key,
+        )
+
+    def list_attention_translations(self, template_id: str) -> dict:
+        """Per language: how many attention points are approved, stale, draft
+        or missing. `complete` = usable for envelopes in that language."""
+        return self._client.request(
+            "GET", f"/templates/{_id(template_id)}/attention-points/translations/"
+        )
+
+    def get_attention_translation(self, template_id: str, language: str) -> dict:
+        """The attention points in one language, with their source text."""
+        return self._client.request(
+            "GET", f"/templates/{_id(template_id)}/attention-points/translations/{_seg(language)}/"
+        )
+
+    def set_attention_translation(self, template_id: str, language: str, points: list) -> dict:
+        """Write the text of one or more points in a language, as drafts:
+        `points=[{"point_id": ..., "title": ..., "body": ...}]`. Approval is
+        a human act in the panel."""
+        return self._client.request(
+            "PUT",
+            f"/templates/{_id(template_id)}/attention-points/translations/{_seg(language)}/",
+            json={"points": points},
+        )
+
+    def delete_attention_translation(self, template_id: str, language: str):
+        return self._client.request(
+            "DELETE",
+            f"/templates/{_id(template_id)}/attention-points/translations/{_seg(language)}/",
+        )
+
+    def autotranslate_attention_points(
+        self,
+        template_id: str,
+        language: str,
+        *,
+        acknowledge: bool,
+        overwrite: bool = False,
+        idempotency_key: str | None = None,
+    ) -> dict:
+        """Queue a MACHINE DRAFT of the attention points in `language` (202,
+        poll `get_translation_job`). A document's autotranslation drafts
+        them too. `overwrite` also replaces points with their own or an
+        approved text."""
+        return self._client.request(
+            "POST",
+            f"/templates/{_id(template_id)}/attention-points/translations/{_seg(language)}/autotranslate/",
+            json={"acknowledge": acknowledge, "overwrite": overwrite},
+            idempotency_key=idempotency_key,
+        )
+
     def add_field(
         self,
         template_id: str,
@@ -768,12 +1195,19 @@ class Templates(_Resource):
         kyc_images_retention: str | None = None,
         biometrics: bool = False,
         project: str | None = None,
+        countersign: str | None = None,
+        attention_points: list[dict] | None = None,
         idempotency_key: str | None = None,
     ) -> dict:
         """The one-call automation flow (§10.4): instantiate and optionally
         send, getting each signer's sign_url back for embedded flows.
         `variables` fills the tokens of authored documents; `language` picks
-        the source or an approved translation."""
+        the source or an approved translation. `countersign="none"` creates it
+        without the organization's automatic countersignature (default
+        "auto": countersigned when the template has an active authorization;
+        other values than the authorized ones give 409). `attention_points`
+        replaces the template's for this envelope only (Pro and Enterprise;
+        None = the template's, [] = none)."""
         body: dict = {
             "signers": signers,
             "title": title,
@@ -792,6 +1226,10 @@ class Templates(_Resource):
             body["expires_in_days"] = expires_in_days
         if project:
             body["project"] = project
+        if countersign:
+            body["countersign"] = countersign
+        if attention_points is not None:
+            body["attention_points"] = attention_points
         return self._client.request(
             "POST",
             f"/templates/{_id(template_id)}/envelopes/",
@@ -799,6 +1237,69 @@ class Templates(_Resource):
             idempotency_key=idempotency_key,
         )
 
+    def request_countersign_authorization(
+        self,
+        template_id: str,
+        *,
+        authorizer_email: str,
+        authorizer_title: str,
+        valid_until: str,
+        max_uses: int | None = None,
+        variables: dict | None = None,
+        project: str | None = None,
+        scope: str | None = None,
+    ) -> dict:
+        """Ask an owner/admin to sign the standing authorization for the
+        organization's automatic countersignature (Pro+). The signing link
+        goes to the authorizer by e-mail only; it becomes active when signed.
+        ``scope``: ``"version"`` (default, the approved version in use only) or
+        ``"future_versions"`` (also the versions approved later, except one
+        adding variables whose values it does not fix)."""
+        body: dict = {
+            "authorizer_email": authorizer_email,
+            "authorizer_title": authorizer_title,
+            "valid_until": valid_until,
+            "variables": variables or {},
+        }
+        if max_uses is not None:
+            body["max_uses"] = max_uses
+        if project:
+            body["project"] = project
+        if scope:
+            body["scope"] = scope
+        return self._client.request(
+            "POST", f"/templates/{_id(template_id)}/countersign-authorizations/", json=body
+        )
+
+    def list_countersign_authorizations(
+        self, template_id: str, *, limit: int | None = None, cursor: str | None = None
+    ) -> dict:
+        params = {k: v for k, v in {"limit": limit, "cursor": cursor}.items() if v is not None}
+        return self._client.request(
+            "GET", f"/templates/{_id(template_id)}/countersign-authorizations/", params=params
+        )
+
+
+class CountersignAuthorizations(_Resource):
+    """Standing authorizations for the organization's automatic
+    countersignature (docs: «Contrafirma automática»)."""
+
+    def list(self, *, limit: int | None = None, cursor: str | None = None) -> dict:
+        params = {k: v for k, v in {"limit": limit, "cursor": cursor}.items() if v is not None}
+        return self._client.request("GET", "/countersign-authorizations/", params=params)
+
+    def get(self, authorization_id: str) -> dict:
+        return self._client.request("GET", f"/countersign-authorizations/{_id(authorization_id)}/")
+
+    def revoke(self, authorization_id: str, *, reason: str = "") -> dict:
+        """Revoke an active one (what was countersigned stays) or cancel a
+        pending one (its signing envelope is voided)."""
+        return self._client.request(
+            "POST",
+            f"/countersign-authorizations/{_id(authorization_id)}/revoke/",
+            json={"reason": reason},
+        )
+
 
 class Webhooks(_Resource):
     def create(
@@ -1029,6 +1530,28 @@ class Organization(_Resource):
         """Org info including plan limits and features."""
         return self._client.request("GET", "/organization/")
 
+    def group(self) -> dict:
+        """The organization group (Enterprise): the group, its members and the
+        invitations received. Read only: the acts happen in the panel."""
+        return self._client.request("GET", "/organization/group/")
+
+    def group_templates(self) -> dict:
+        """Templates the other organizations of the group offer (approved
+        version, names only)."""
+        return self._client.request("GET", "/organization/group/templates/")
+
+    def copy_group_template(
+        self, template_id: str, *, name: str = "", idempotency_key: str | None = None
+    ) -> dict:
+        """Copy an offered template into this organization as a new DRAFT
+        (translations too): approve it and request its own countersign."""
+        return self._client.request(
+            "POST",
+            f"/organization/group/templates/{_id(template_id)}/copy/",
+            json={"name": name} if name else {},
+            idempotency_key=idempotency_key,
+        )
+
     def update(
         self,
         *,