resolver_curation#

curl -X GET "/db/v1/tables/{tableName}/resolvers" \
    -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch('/db/v1/tables/{tableName}/resolvers', {
    method: 'GET',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
    }
});

const data = await response.json();

fetch('/db/v1/tables/{tableName}/resolvers', {
    method: 'GET',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
    }
})
    .then(response => response.json())
    .then(data => console.log(data));

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY'
}

response = requests.get('/db/v1/tables/{tableName}/resolvers', headers=headers)

data = response.json()

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("GET", "/db/v1/tables/{tableName}/resolvers", nil)
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

{
  "resolvers": [
    {
      "name": "string",
      "source_table": "string",
      "entity_table": "string",
      "key_template": "string",
      "declaring_indexes": [
        "string"
      ],
      "retired": true,
      "config": {
        "name": "string",
        "table": "string",
        "source_artifact": "string",
        "source_artifact_kind": "asset",
        "resolution_artifact": "string",
        "key_template": "string",
        "promote": true,
        "aliases": [
          {
            "key": "string",
            "target": "string"
          }
        ],
        "labels": [
          "string"
        ],
        "type_must_match": true,
        "scorer": {
          "comparisons": [
            {
              "name": "string",
              "left": "string",
              "right": "string",
              "levels": [
                {
                  "when": "string",
                  "else": true,
                  "weight": 0
                }
              ]
            }
          ],
          "combine": {
            "bias": 0
          },
          "decision": {
            "match": 0,
            "review": 0
          }
        },
        "adjudicate": {
          "decider": {
            "provider": "antfly",
            "decision_method": "typed",
            "generator": {
              "provider": "openai",
              "model": "gpt-4.1",
              "temperature": 0.7,
              "max_tokens": 2048
            },
            "instructions": "string",
            "output": "auto",
            "probabilities": "token_logprobs",
            "batch": {
              "max_items_per_call": 1,
              "max_input_bytes": 1
            },
            "model": "string",
            "model_identity": "string",
            "embedding_options": {
              "calibration_id": "string",
              "task_type": "CLUSTERING",
              "dimensions": 768,
              "min_similarity": -1,
              "min_margin": 0
            },
            "url": "string",
            "api_key": "string",
            "max_rows": 1,
            "max_input_tokens": 1,
            "max_image_input_tokens": 1,
            "rate_limit": {
              "pacing": "token_bucket",
              "requests_per_minute": 1,
              "burst": 1,
              "tokens_per_minute": 1,
              "max_concurrency": 1
            },
            "batch_size": 1
          },
          "template": "string",
          "question": {
            "type": "choice",
            "name": "string",
            "instructions": "string",
            "choices": [
              {
                "value": "string",
                "description": "string",
                "examples": [
                  "string"
                ]
              }
            ],
            "embedding_options": {
              "calibration_id": "string",
              "min_similarity": -1,
              "min_margin": 0
            }
          },
          "accept": {
            "choice": "string",
            "min_probability": 0.5
          },
          "reject": {
            "choice": "string",
            "min_probability": 0.5
          },
          "on_failure": "review",
          "description_inputs": {
            "mention_artifact": "string",
            "candidate_artifact": "string"
          },
          "budget_ms": 1,
          "max_pairs": 1,
          "max_input_bytes": 1,
          "timeout_ms": 1
        },
        "suppress": {
          "keys": [
            "string"
          ],
          "texts": [
            "string"
          ],
          "min_text_chars": 0
        },
        "scorer_json": "string",
        "candidate_search": "",
        "candidate_ann_index": "string",
        "candidate_limit": 0,
        "name_embedding": "string",
        "name_embedding_dims": 0,
        "fusion_combine": "",
        "fusion_trust": 0,
        "fusion_prior": 0,
        "fusion_prior_weight": 0,
        "min_confidence": 0,
        "config_generation": 0
      },
      "revision": 0,
      "namespace_generation": 0,
      "redirects": [
        {
          "key": "string",
          "target": "string",
          "origin": {
            "origin": "manual",
            "actor": "string",
            "reason": "string",
            "created_at_ms": 0,
            "revision": 0,
            "proposal_id": "string",
            "cascade_from": "string"
          }
        }
      ],
      "curation": {
        "version": 1,
        "suppress": {
          "keys": [
            "string"
          ],
          "texts": [
            "string"
          ],
          "min_text_chars": 0,
          "entries": [
            {
              "key": "string",
              "origin": {
                "origin": "manual",
                "actor": "string",
                "reason": "string",
                "created_at_ms": 0,
                "revision": 0,
                "proposal_id": "string",
                "cascade_from": "string"
              }
            }
          ],
          "text_entries": [
            {
              "key": "string",
              "origin": {
                "origin": "manual",
                "actor": "string",
                "reason": "string",
                "created_at_ms": 0,
                "revision": 0,
                "proposal_id": "string",
                "cascade_from": "string"
              }
            }
          ]
        },
        "distinct": [
          {
            "from": "string",
            "to": "string",
            "origin": {
              "origin": "manual",
              "actor": "string",
              "reason": "string",
              "created_at_ms": 0,
              "revision": 0,
              "proposal_id": "string",
              "cascade_from": "string"
            }
          }
        ],
        "removed_aliases": [
          "string"
        ]
      },
      "progress": {
        "applied": true,
        "shards": [
          {
            "group_id": 0,
            "available": true,
            "fresh": true,
            "curation_revision": 0,
            "config_generation": 0,
            "effective_generation": 0,
            "backfill_pending": true,
            "resolution": {
              "enabled": true,
              "target_sequence": 0,
              "applied_sequence": 0,
              "catch_up_required": true,
              "blocked": true,
              "blocked_reason": "string",
              "error_count": 0
            },
            "promotion": {
              "enabled": true,
              "target_sequence": 0,
              "applied_sequence": 0,
              "catch_up_required": true,
              "blocked": true,
              "blocked_reason": "string",
              "error_count": 0
            }
          }
        ],
        "observation_error": "string"
      }
    }
  ]
}

curl -X GET "/db/v1/tables/{tableName}/resolvers/{resolverName}" \
    -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch('/db/v1/tables/{tableName}/resolvers/{resolverName}', {
    method: 'GET',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
    }
});

const data = await response.json();

fetch('/db/v1/tables/{tableName}/resolvers/{resolverName}', {
    method: 'GET',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
    }
})
    .then(response => response.json())
    .then(data => console.log(data));

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY'
}

response = requests.get('/db/v1/tables/{tableName}/resolvers/{resolverName}', headers=headers)

data = response.json()

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("GET", "/db/v1/tables/{tableName}/resolvers/{resolverName}", nil)
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

{
  "name": "string",
  "source_table": "string",
  "entity_table": "string",
  "key_template": "string",
  "declaring_indexes": [
    "string"
  ],
  "retired": true,
  "config": {
    "name": "string",
    "table": "string",
    "source_artifact": "string",
    "source_artifact_kind": "asset",
    "resolution_artifact": "string",
    "key_template": "string",
    "promote": true,
    "aliases": [
      {
        "key": "string",
        "target": "string"
      }
    ],
    "labels": [
      "string"
    ],
    "type_must_match": true,
    "scorer": {
      "comparisons": [
        {
          "name": "string",
          "left": "string",
          "right": "string",
          "levels": [
            {
              "when": "string",
              "else": true,
              "weight": 0
            }
          ]
        }
      ],
      "combine": {
        "bias": 0
      },
      "decision": {
        "match": 0,
        "review": 0
      }
    },
    "adjudicate": {
      "decider": {
        "provider": "antfly",
        "decision_method": "typed",
        "generator": {
          "provider": "openai",
          "model": "gpt-4.1",
          "temperature": 0.7,
          "max_tokens": 2048
        },
        "instructions": "string",
        "output": "auto",
        "probabilities": "token_logprobs",
        "batch": {
          "max_items_per_call": 1,
          "max_input_bytes": 1
        },
        "model": "string",
        "model_identity": "string",
        "embedding_options": {
          "calibration_id": "string",
          "task_type": "CLUSTERING",
          "dimensions": 768,
          "min_similarity": -1,
          "min_margin": 0
        },
        "url": "string",
        "api_key": "string",
        "max_rows": 1,
        "max_input_tokens": 1,
        "max_image_input_tokens": 1,
        "rate_limit": {
          "pacing": "token_bucket",
          "requests_per_minute": 1,
          "burst": 1,
          "tokens_per_minute": 1,
          "max_concurrency": 1
        },
        "batch_size": 1
      },
      "template": "string",
      "question": {
        "type": "choice",
        "name": "string",
        "instructions": "string",
        "choices": [
          {
            "value": "string",
            "description": "string",
            "examples": [
              "string"
            ]
          }
        ],
        "embedding_options": {
          "calibration_id": "string",
          "min_similarity": -1,
          "min_margin": 0
        }
      },
      "accept": {
        "choice": "string",
        "min_probability": 0.5
      },
      "reject": {
        "choice": "string",
        "min_probability": 0.5
      },
      "on_failure": "review",
      "description_inputs": {
        "mention_artifact": "string",
        "candidate_artifact": "string"
      },
      "budget_ms": 1,
      "max_pairs": 1,
      "max_input_bytes": 1,
      "timeout_ms": 1
    },
    "suppress": {
      "keys": [
        "string"
      ],
      "texts": [
        "string"
      ],
      "min_text_chars": 0
    },
    "scorer_json": "string",
    "candidate_search": "",
    "candidate_ann_index": "string",
    "candidate_limit": 0,
    "name_embedding": "string",
    "name_embedding_dims": 0,
    "fusion_combine": "",
    "fusion_trust": 0,
    "fusion_prior": 0,
    "fusion_prior_weight": 0,
    "min_confidence": 0,
    "config_generation": 0
  },
  "revision": 0,
  "namespace_generation": 0,
  "redirects": [
    {
      "key": "string",
      "target": "string",
      "origin": {
        "origin": "manual",
        "actor": "string",
        "reason": "string",
        "created_at_ms": 0,
        "revision": 0,
        "proposal_id": "string",
        "cascade_from": "string"
      }
    }
  ],
  "curation": {
    "version": 1,
    "suppress": {
      "keys": [
        "string"
      ],
      "texts": [
        "string"
      ],
      "min_text_chars": 0,
      "entries": [
        {
          "key": "string",
          "origin": {
            "origin": "manual",
            "actor": "string",
            "reason": "string",
            "created_at_ms": 0,
            "revision": 0,
            "proposal_id": "string",
            "cascade_from": "string"
          }
        }
      ],
      "text_entries": [
        {
          "key": "string",
          "origin": {
            "origin": "manual",
            "actor": "string",
            "reason": "string",
            "created_at_ms": 0,
            "revision": 0,
            "proposal_id": "string",
            "cascade_from": "string"
          }
        }
      ]
    },
    "distinct": [
      {
        "from": "string",
        "to": "string",
        "origin": {
          "origin": "manual",
          "actor": "string",
          "reason": "string",
          "created_at_ms": 0,
          "revision": 0,
          "proposal_id": "string",
          "cascade_from": "string"
        }
      }
    ],
    "removed_aliases": [
      "string"
    ]
  },
  "progress": {
    "applied": true,
    "shards": [
      {
        "group_id": 0,
        "available": true,
        "fresh": true,
        "curation_revision": 0,
        "config_generation": 0,
        "effective_generation": 0,
        "backfill_pending": true,
        "resolution": {
          "enabled": true,
          "target_sequence": 0,
          "applied_sequence": 0,
          "catch_up_required": true,
          "blocked": true,
          "blocked_reason": "string",
          "error_count": 0
        },
        "promotion": {
          "enabled": true,
          "target_sequence": 0,
          "applied_sequence": 0,
          "catch_up_required": true,
          "blocked": true,
          "blocked_reason": "string",
          "error_count": 0
        }
      }
    ],
    "observation_error": "string"
  }
}

curl -X DELETE "/db/v1/tables/{tableName}/resolvers/{resolverName}" \
    -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch('/db/v1/tables/{tableName}/resolvers/{resolverName}', {
    method: 'DELETE',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
    }
});

const data = await response.json();

fetch('/db/v1/tables/{tableName}/resolvers/{resolverName}', {
    method: 'DELETE',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
    }
})
    .then(response => response.json())
    .then(data => console.log(data));

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY'
}

response = requests.delete('/db/v1/tables/{tableName}/resolvers/{resolverName}', headers=headers)

data = response.json()

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("DELETE", "/db/v1/tables/{tableName}/resolvers/{resolverName}", nil)
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

{
  "resolver": "string",
  "changed": true,
  "revision": 0,
  "replay_sequence": 0,
  "replay_sequence_kind": "resolver_revision",
  "metadata_commit": {},
  "applied": true,
  "progress": {
    "applied": true,
    "shards": [
      {
        "group_id": 0,
        "available": true,
        "fresh": true,
        "curation_revision": 0,
        "config_generation": 0,
        "effective_generation": 0,
        "backfill_pending": true,
        "resolution": {
          "enabled": true,
          "target_sequence": 0,
          "applied_sequence": 0,
          "catch_up_required": true,
          "blocked": true,
          "blocked_reason": "string",
          "error_count": 0
        },
        "promotion": {
          "enabled": true,
          "target_sequence": 0,
          "applied_sequence": 0,
          "catch_up_required": true,
          "blocked": true,
          "blocked_reason": "string",
          "error_count": 0
        }
      }
    ],
    "observation_error": "string"
  }
}

{
  "resolver": "string",
  "changed": true,
  "revision": 0,
  "replay_sequence": 0,
  "replay_sequence_kind": "resolver_revision",
  "metadata_commit": {},
  "applied": true,
  "progress": {
    "applied": true,
    "shards": [
      {
        "group_id": 0,
        "available": true,
        "fresh": true,
        "curation_revision": 0,
        "config_generation": 0,
        "effective_generation": 0,
        "backfill_pending": true,
        "resolution": {
          "enabled": true,
          "target_sequence": 0,
          "applied_sequence": 0,
          "catch_up_required": true,
          "blocked": true,
          "blocked_reason": "string",
          "error_count": 0
        },
        "promotion": {
          "enabled": true,
          "target_sequence": 0,
          "applied_sequence": 0,
          "catch_up_required": true,
          "blocked": true,
          "blocked_reason": "string",
          "error_count": 0
        }
      }
    ],
    "observation_error": "string"
  }
}

curl -X POST "/db/v1/tables/{tableName}/resolvers/{resolverName}:render" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
    "text": "string",
    "label": "string",
    "local_id": "string"
}'

const response = await fetch('/db/v1/tables/{tableName}/resolvers/{resolverName}:render', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        "text": "string",
        "label": "string",
        "local_id": "string"
    })
});

const data = await response.json();

fetch('/db/v1/tables/{tableName}/resolvers/{resolverName}:render', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        "text": "string",
        "label": "string",
        "local_id": "string"
    })
})
    .then(response => response.json())
    .then(data => console.log(data));

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY'
}

response = requests.post(
    '/db/v1/tables/{tableName}/resolvers/{resolverName}:render',
    headers=headers,
    json={
        "text": "string",
        "label": "string",
        "local_id": "string"
    }
)

data = response.json()

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    body := []byte(`{
    "text": "string",
    "label": "string",
    "local_id": "string"
}`)
    req, _ := http.NewRequest("POST", "/db/v1/tables/{tableName}/resolvers/{resolverName}:render", bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

{
  "minted_key": "string",
  "key": "string",
  "table": "string",
  "config_generation": 0,
  "suppressed": true
}

curl -X POST "/db/v1/tables/{tableName}/resolvers/{resolverName}:resolve" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
    "text": "string",
    "extraction": {}
}'

const response = await fetch('/db/v1/tables/{tableName}/resolvers/{resolverName}:resolve', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        "text": "string",
        "extraction": {}
    })
});

const data = await response.json();

fetch('/db/v1/tables/{tableName}/resolvers/{resolverName}:resolve', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        "text": "string",
        "extraction": {}
    })
})
    .then(response => response.json())
    .then(data => console.log(data));

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY'
}

response = requests.post(
    '/db/v1/tables/{tableName}/resolvers/{resolverName}:resolve',
    headers=headers,
    json={
        "text": "string",
        "extraction": {}
    }
)

data = response.json()

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    body := []byte(`{
    "text": "string",
    "extraction": {}
}`)
    req, _ := http.NewRequest("POST", "/db/v1/tables/{tableName}/resolvers/{resolverName}:resolve", bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

{
  "extraction": {},
  "resolution": {
    "config_generation": 0,
    "skipped_mentions": 0,
    "entities": [
      {
        "local_id": "string",
        "doc_ref": {
          "table": "string",
          "key": "string",
          "storage_table": "string"
        },
        "confidence": 0,
        "decision": "new",
        "label": "string",
        "canonical_name": "string",
        "surface_form": "string",
        "rendered_key": "string",
        "redirected_from": "string",
        "suppressed": true,
        "suppression_reason": "key",
        "identity_restored": true,
        "adjudication": {
          "execution_hash": "string",
          "specification_hash": "string",
          "input_hash": "string",
          "candidate_hash": "string",
          "candidate_table": "string",
          "candidate_key": "string",
          "deterministic_probability": 0,
          "status": "accepted",
          "response": {},
          "failure": "string"
        }
      }
    ],
    "_resolution_work": {}
  }
}

curl -X POST "/db/v1/tables/{tableName}/resolvers/{resolverName}:namespace" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
    "table": "string",
    "key_template": "string",
    "reset_merges": true,
    "reset_curation": true,
    "key_map": [
        {
            "key": "string",
            "target": "string",
            "origin": {
                "origin": "manual",
                "actor": "string",
                "reason": "string",
                "created_at_ms": 0,
                "revision": 0,
                "proposal_id": "string",
                "cascade_from": "string"
            }
        }
    ],
    "aliases": [
        {
            "key": "string",
            "target": "string",
            "origin": {
                "origin": "manual",
                "actor": "string",
                "reason": "string",
                "created_at_ms": 0,
                "revision": 0,
                "proposal_id": "string",
                "cascade_from": "string"
            }
        }
    ],
    "expected_revision": 0,
    "wait": {
        "timeout_ms": 1
    }
}'

const response = await fetch('/db/v1/tables/{tableName}/resolvers/{resolverName}:namespace', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        "table": "string",
        "key_template": "string",
        "reset_merges": true,
        "reset_curation": true,
        "key_map": [
            {
                "key": "string",
                "target": "string",
                "origin": {
                    "origin": "manual",
                    "actor": "string",
                    "reason": "string",
                    "created_at_ms": 0,
                    "revision": 0,
                    "proposal_id": "string",
                    "cascade_from": "string"
                }
            }
        ],
        "aliases": [
            {
                "key": "string",
                "target": "string",
                "origin": {
                    "origin": "manual",
                    "actor": "string",
                    "reason": "string",
                    "created_at_ms": 0,
                    "revision": 0,
                    "proposal_id": "string",
                    "cascade_from": "string"
                }
            }
        ],
        "expected_revision": 0,
        "wait": {
            "timeout_ms": 1
        }
    })
});

const data = await response.json();

fetch('/db/v1/tables/{tableName}/resolvers/{resolverName}:namespace', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        "table": "string",
        "key_template": "string",
        "reset_merges": true,
        "reset_curation": true,
        "key_map": [
            {
                "key": "string",
                "target": "string",
                "origin": {
                    "origin": "manual",
                    "actor": "string",
                    "reason": "string",
                    "created_at_ms": 0,
                    "revision": 0,
                    "proposal_id": "string",
                    "cascade_from": "string"
                }
            }
        ],
        "aliases": [
            {
                "key": "string",
                "target": "string",
                "origin": {
                    "origin": "manual",
                    "actor": "string",
                    "reason": "string",
                    "created_at_ms": 0,
                    "revision": 0,
                    "proposal_id": "string",
                    "cascade_from": "string"
                }
            }
        ],
        "expected_revision": 0,
        "wait": {
            "timeout_ms": 1
        }
    })
})
    .then(response => response.json())
    .then(data => console.log(data));

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY'
}

response = requests.post(
    '/db/v1/tables/{tableName}/resolvers/{resolverName}:namespace',
    headers=headers,
    json={
        "table": "string",
        "key_template": "string",
        "reset_merges": true,
        "reset_curation": true,
        "key_map": [
            {
                "key": "string",
                "target": "string",
                "origin": {
                    "origin": "manual",
                    "actor": "string",
                    "reason": "string",
                    "created_at_ms": 0,
                    "revision": 0,
                    "proposal_id": "string",
                    "cascade_from": "string"
                }
            }
        ],
        "aliases": [
            {
                "key": "string",
                "target": "string",
                "origin": {
                    "origin": "manual",
                    "actor": "string",
                    "reason": "string",
                    "created_at_ms": 0,
                    "revision": 0,
                    "proposal_id": "string",
                    "cascade_from": "string"
                }
            }
        ],
        "expected_revision": 0,
        "wait": {
            "timeout_ms": 1
        }
    }
)

data = response.json()

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    body := []byte(`{
    "table": "string",
    "key_template": "string",
    "reset_merges": true,
    "reset_curation": true,
    "key_map": [
        {
            "key": "string",
            "target": "string",
            "origin": {
                "origin": "manual",
                "actor": "string",
                "reason": "string",
                "created_at_ms": 0,
                "revision": 0,
                "proposal_id": "string",
                "cascade_from": "string"
            }
        }
    ],
    "aliases": [
        {
            "key": "string",
            "target": "string",
            "origin": {
                "origin": "manual",
                "actor": "string",
                "reason": "string",
                "created_at_ms": 0,
                "revision": 0,
                "proposal_id": "string",
                "cascade_from": "string"
            }
        }
    ],
    "expected_revision": 0,
    "wait": {
        "timeout_ms": 1
    }
}`)
    req, _ := http.NewRequest("POST", "/db/v1/tables/{tableName}/resolvers/{resolverName}:namespace", bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

{
  "resolver": "string",
  "changed": true,
  "revision": 0,
  "replay_sequence": 0,
  "replay_sequence_kind": "resolver_revision",
  "metadata_commit": {},
  "applied": true,
  "progress": {
    "applied": true,
    "shards": [
      {
        "group_id": 0,
        "available": true,
        "fresh": true,
        "curation_revision": 0,
        "config_generation": 0,
        "effective_generation": 0,
        "backfill_pending": true,
        "resolution": {
          "enabled": true,
          "target_sequence": 0,
          "applied_sequence": 0,
          "catch_up_required": true,
          "blocked": true,
          "blocked_reason": "string",
          "error_count": 0
        },
        "promotion": {
          "enabled": true,
          "target_sequence": 0,
          "applied_sequence": 0,
          "catch_up_required": true,
          "blocked": true,
          "blocked_reason": "string",
          "error_count": 0
        }
      }
    ],
    "observation_error": "string"
  }
}

{
  "resolver": "string",
  "changed": true,
  "revision": 0,
  "replay_sequence": 0,
  "replay_sequence_kind": "resolver_revision",
  "metadata_commit": {},
  "applied": true,
  "progress": {
    "applied": true,
    "shards": [
      {
        "group_id": 0,
        "available": true,
        "fresh": true,
        "curation_revision": 0,
        "config_generation": 0,
        "effective_generation": 0,
        "backfill_pending": true,
        "resolution": {
          "enabled": true,
          "target_sequence": 0,
          "applied_sequence": 0,
          "catch_up_required": true,
          "blocked": true,
          "blocked_reason": "string",
          "error_count": 0
        },
        "promotion": {
          "enabled": true,
          "target_sequence": 0,
          "applied_sequence": 0,
          "catch_up_required": true,
          "blocked": true,
          "blocked_reason": "string",
          "error_count": 0
        }
      }
    ],
    "observation_error": "string"
  }
}

curl -X GET "/db/v1/tables/{tableName}/resolvers/{resolverName}/redirects" \
    -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch('/db/v1/tables/{tableName}/resolvers/{resolverName}/redirects', {
    method: 'GET',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
    }
});

const data = await response.json();

fetch('/db/v1/tables/{tableName}/resolvers/{resolverName}/redirects', {
    method: 'GET',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
    }
})
    .then(response => response.json())
    .then(data => console.log(data));

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY'
}

response = requests.get('/db/v1/tables/{tableName}/resolvers/{resolverName}/redirects', headers=headers)

data = response.json()

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("GET", "/db/v1/tables/{tableName}/resolvers/{resolverName}/redirects", nil)
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}