begin;

create or replace function public.conversational_rectification_has_only_keys(
  p_value jsonb,
  p_allowed text[]
)
returns boolean
language sql
immutable
strict
set search_path = ''
as $$
  select pg_catalog.jsonb_typeof(p_value) = 'object'
    and not exists (
      select 1
      from pg_catalog.jsonb_object_keys(p_value) key
      where not (key = any (p_allowed))
    );
$$;

create or replace function public.conversational_rectification_valid_time_text(p_value text)
returns boolean
language sql
immutable
strict
set search_path = ''
as $$
  select p_value ~ '^([01][0-9]|2[0-3]):[0-5][0-9]$';
$$;

create or replace function public.conversational_rectification_valid_date_text(p_value text)
returns boolean
language plpgsql
immutable
strict
set search_path = ''
as $$
begin
  return p_value ~ '^[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}$'
    and pg_catalog.to_char(p_value::date, 'YYYY-MM-DD') = p_value;
exception when others then
  return false;
end;
$$;

create or replace function public.conversational_rectification_valid_uuid_text(p_value text)
returns boolean
language plpgsql
immutable
strict
set search_path = ''
as $$
begin
  if p_value !~* '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$' then
    return false;
  end if;
  perform p_value::uuid;
  return true;
exception when others then
  return false;
end;
$$;

create or replace function public.conversational_rectification_text_utf16_length(
  p_value text
)
returns integer
language sql
immutable
strict
set search_path = ''
as $$
  select pg_catalog.char_length(p_value) + (
    select pg_catalog.count(*)::integer
    from pg_catalog.generate_series(
      1, pg_catalog.char_length(p_value)
    ) character_positions(character_index)
    where pg_catalog.octet_length(
      pg_catalog.substr(p_value, character_index, 1)
    ) = 4
  );
$$;

create or replace function public.conversational_rectification_text_is_nonblank(
  p_value text
)
returns boolean
language sql
immutable
strict
set search_path = ''
as $$
  select pg_catalog.btrim(
    p_value,
    U&'\0009\000A\000B\000C\000D\0020\00A0\1680\2000\2001\2002\2003\2004\2005\2006\2007\2008\2009\200A\2028\2029\202F\205F\3000\FEFF'
  ) <> '';
$$;

create or replace function public.conversational_rectification_numbers_are_stable(
  p_value jsonb
)
returns boolean
language plpgsql
immutable
strict
set search_path = ''
as $$
declare
  v_item jsonb;
  v_number numeric;
begin
  if pg_catalog.jsonb_typeof(p_value) = 'number' then
    v_number := (p_value #>> '{}')::numeric;
    if v_number = pg_catalog.trunc(v_number) then
      return pg_catalog.abs(v_number) <= 9007199254740991;
    end if;
    return pg_catalog.abs(v_number) between 0.000001 and 1000000
      and v_number = pg_catalog.trunc(v_number, 6);
  elsif pg_catalog.jsonb_typeof(p_value) = 'array' then
    for v_item in select value from pg_catalog.jsonb_array_elements(p_value) loop
      if public.conversational_rectification_numbers_are_stable(v_item) is not true then
        return false;
      end if;
    end loop;
  elsif pg_catalog.jsonb_typeof(p_value) = 'object' then
    for v_item in select value from pg_catalog.jsonb_each(p_value) loop
      if public.conversational_rectification_numbers_are_stable(v_item) is not true then
        return false;
      end if;
    end loop;
  end if;
  return true;
exception when others then
  return false;
end;
$$;

create or replace function public.conversational_rectification_text_array_is_bounded(
  p_value jsonb,
  p_max_items integer,
  p_max_characters integer,
  p_max_bytes integer
)
returns boolean
language sql
immutable
strict
set search_path = ''
as $$
  select pg_catalog.jsonb_typeof(p_value) = 'array'
    and pg_catalog.jsonb_array_length(p_value) <= p_max_items
    and pg_catalog.octet_length(p_value::text) <= p_max_bytes
    and not exists (
      select 1
      from pg_catalog.jsonb_array_elements(p_value) item
      where pg_catalog.jsonb_typeof(item) is distinct from 'string'
        or public.conversational_rectification_text_utf16_length(
          item #>> '{}'
        ) not between 1 and p_max_characters
        or public.conversational_rectification_text_is_nonblank(item #>> '{}') is not true
    );
$$;

create or replace function public.conversational_rectification_valid_candidate(p_value jsonb)
returns boolean
language plpgsql
immutable
strict
set search_path = ''
as $$
declare
  v_key text;
begin
  if pg_catalog.jsonb_typeof(p_value) is distinct from 'object'
    or pg_catalog.octet_length(p_value::text) > 512
    or public.conversational_rectification_numbers_are_stable(p_value) is not true
    or not public.conversational_rectification_has_only_keys(
      p_value,
      array['status', 'representativeTime', 'rangeStart', 'rangeEnd']::text[]
    )
    or not (p_value ?& array['status', 'representativeTime', 'rangeStart', 'rangeEnd']::text[])
    or pg_catalog.jsonb_typeof(p_value -> 'status') is distinct from 'string'
    or p_value ->> 'status' not in (
      'declared', 'pending_validation', 'ready_for_confirmation', 'confirmed'
    ) then
    return false;
  end if;
  foreach v_key in array array['representativeTime', 'rangeStart', 'rangeEnd']::text[] loop
    if p_value -> v_key <> 'null'::jsonb
      and (
        pg_catalog.jsonb_typeof(p_value -> v_key) is distinct from 'string'
        or not public.conversational_rectification_valid_time_text(p_value ->> v_key)
      ) then
      return false;
    end if;
  end loop;
  return true;
exception when others then
  return false;
end;
$$;

create or replace function public.conversational_rectification_valid_technical_receipt(
  p_value jsonb
)
returns boolean
language sql
immutable
strict
set search_path = ''
as $$
  select pg_catalog.jsonb_typeof(p_value) = 'object'
    and pg_catalog.octet_length(p_value::text) <= 8192
    and public.conversational_rectification_numbers_are_stable(p_value)
    and public.conversational_rectification_has_only_keys(
      p_value,
      array[
        'calculationVersion', 'stableLayers', 'sensitiveLayers',
        'candidateDifferenceRefs'
      ]::text[]
    )
    and p_value ?& array[
      'calculationVersion', 'stableLayers', 'sensitiveLayers',
      'candidateDifferenceRefs'
    ]::text[]
    and pg_catalog.jsonb_typeof(p_value -> 'calculationVersion') = 'string'
    and public.conversational_rectification_text_utf16_length(
      p_value ->> 'calculationVersion'
    ) between 1 and 80
    and public.conversational_rectification_text_is_nonblank(
      p_value ->> 'calculationVersion'
    )
    and public.conversational_rectification_text_array_is_bounded(
      p_value -> 'stableLayers', 20, 80, 4096
    )
    and public.conversational_rectification_text_array_is_bounded(
      p_value -> 'sensitiveLayers', 20, 80, 4096
    )
    and public.conversational_rectification_text_array_is_bounded(
      p_value -> 'candidateDifferenceRefs', 40, 120, 8192
    );
$$;

create or replace function public.conversational_rectification_valid_evidence_request(
  p_value jsonb
)
returns boolean
language sql
immutable
strict
set search_path = ''
as $$
  select pg_catalog.jsonb_typeof(p_value) = 'object'
    and pg_catalog.octet_length(p_value::text) <= 2048
    and public.conversational_rectification_numbers_are_stable(p_value)
    and public.conversational_rectification_has_only_keys(
      p_value,
      array['domains', 'datePrecision', 'freeTextAllowed']::text[]
    )
    and p_value ?& array['domains', 'datePrecision', 'freeTextAllowed']::text[]
    and pg_catalog.jsonb_typeof(p_value -> 'domains') = 'array'
    and pg_catalog.jsonb_array_length(p_value -> 'domains') between 2 and 4
    and not exists (
      select 1
      from pg_catalog.jsonb_array_elements(p_value -> 'domains') domain
      where pg_catalog.jsonb_typeof(domain) is distinct from 'string'
        or domain #>> '{}' not in (
          'career', 'education', 'relocation', 'relationship', 'family', 'other'
        )
    )
    and pg_catalog.jsonb_typeof(p_value -> 'datePrecision') = 'string'
    and p_value ->> 'datePrecision' in ('month_preferred', 'year_accepted')
    and pg_catalog.jsonb_typeof(p_value -> 'freeTextAllowed') = 'boolean'
    and p_value -> 'freeTextAllowed' = 'true'::jsonb;
$$;

create or replace function public.conversational_rectification_valid_evidence_recap(
  p_value jsonb
)
returns boolean
language sql
immutable
strict
set search_path = ''
as $$
  select pg_catalog.jsonb_typeof(p_value) = 'array'
    and pg_catalog.octet_length(p_value::text) <= 24576
    and public.conversational_rectification_numbers_are_stable(p_value)
    and pg_catalog.jsonb_array_length(p_value) <= 20
    and not exists (
      select 1
      from pg_catalog.jsonb_array_elements(p_value) item
      where pg_catalog.jsonb_typeof(item) <> 'object'
        or pg_catalog.octet_length(item::text) > 4096
        or not public.conversational_rectification_has_only_keys(
          item, array['id', 'summary', 'dateLabel', 'isCorrection']::text[]
        )
        or not (item ?& array['id', 'summary', 'dateLabel']::text[])
        or pg_catalog.jsonb_typeof(item -> 'id') <> 'string'
        or not public.conversational_rectification_valid_uuid_text(item ->> 'id')
        or pg_catalog.jsonb_typeof(item -> 'summary') <> 'string'
        or public.conversational_rectification_text_utf16_length(
          item ->> 'summary'
        ) not between 1 and 1000
        or public.conversational_rectification_text_is_nonblank(
          item ->> 'summary'
        ) is not true
        or pg_catalog.jsonb_typeof(item -> 'dateLabel') <> 'string'
        or public.conversational_rectification_text_utf16_length(
          item ->> 'dateLabel'
        ) not between 1 and 80
        or public.conversational_rectification_text_is_nonblank(
          item ->> 'dateLabel'
        ) is not true
        or (
          item ? 'isCorrection'
          and pg_catalog.jsonb_typeof(item -> 'isCorrection') <> 'boolean'
        )
    );
$$;

create or replace function public.conversational_rectification_valid_actions(p_value jsonb)
returns boolean
language sql
immutable
strict
set search_path = ''
as $$
  select pg_catalog.jsonb_typeof(p_value) = 'array'
    and pg_catalog.octet_length(p_value::text) <= 512
    and public.conversational_rectification_numbers_are_stable(p_value)
    and pg_catalog.jsonb_array_length(p_value) <= 5
    and not exists (
      select 1
      from pg_catalog.jsonb_array_elements(p_value) action
      where pg_catalog.jsonb_typeof(action) is distinct from 'string'
        or action #>> '{}' not in (
        'answer', 'pause', 'abandon', 'confirm', 'continue_original_question'
      )
    );
$$;

create or replace function public.conversational_rectification_valid_validation_receipt(
  p_value jsonb
)
returns boolean
language plpgsql
immutable
strict
set search_path = ''
as $$
begin
  if pg_catalog.jsonb_typeof(p_value) is distinct from 'object'
    or pg_catalog.octet_length(p_value::text) > 8192
    or public.conversational_rectification_numbers_are_stable(p_value) is not true
    or not public.conversational_rectification_has_only_keys(
      p_value,
      array[
        'modelId', 'schemaValidated', 'validatorVersion', 'validatedAt',
        'retryCount', 'fallbackUsed', 'issues'
      ]::text[]
    )
    or not (p_value ?& array['modelId', 'schemaValidated']::text[])
    or pg_catalog.jsonb_typeof(p_value -> 'modelId') is distinct from 'string'
    or public.conversational_rectification_text_utf16_length(
      p_value ->> 'modelId'
    ) not between 1 and 120
    or public.conversational_rectification_text_is_nonblank(
      p_value ->> 'modelId'
    ) is not true
    or pg_catalog.jsonb_typeof(p_value -> 'schemaValidated') is distinct from 'boolean' then
    return false;
  end if;
  if p_value ? 'validatorVersion' and (
    pg_catalog.jsonb_typeof(p_value -> 'validatorVersion') is distinct from 'string'
    or public.conversational_rectification_text_utf16_length(
      p_value ->> 'validatorVersion'
    ) not between 1 and 80
    or public.conversational_rectification_text_is_nonblank(
      p_value ->> 'validatorVersion'
    ) is not true
  ) then return false; end if;
  if p_value ? 'validatedAt' and (
    pg_catalog.jsonb_typeof(p_value -> 'validatedAt') is distinct from 'string'
    or public.conversational_rectification_text_utf16_length(
      p_value ->> 'validatedAt'
    ) not between 20 and 40
    or public.conversational_rectification_text_is_nonblank(
      p_value ->> 'validatedAt'
    ) is not true
    or p_value ->> 'validatedAt' !~
      '^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+)?(Z|[+-][0-9]{2}:[0-9]{2})$'
    or (p_value ->> 'validatedAt')::timestamptz is null
  ) then return false; end if;
  if p_value ? 'retryCount' and (
    pg_catalog.jsonb_typeof(p_value -> 'retryCount') is distinct from 'number'
    or p_value ->> 'retryCount' !~ '^[0-9]+$'
    or (p_value ->> 'retryCount')::integer not between 0 and 2
  ) then return false; end if;
  if p_value ? 'fallbackUsed'
    and pg_catalog.jsonb_typeof(p_value -> 'fallbackUsed') is distinct from 'boolean' then
    return false;
  end if;
  if p_value ? 'issues' and not public.conversational_rectification_text_array_is_bounded(
    p_value -> 'issues', 20, 240, 8192
  ) then return false; end if;
  return true;
exception when others then
  return false;
end;
$$;

create or replace function public.conversational_rectification_valid_life_event_evidence(
  p_value jsonb
)
returns boolean
language plpgsql
immutable
strict
set search_path = ''
as $$
begin
  if pg_catalog.jsonb_typeof(p_value) is distinct from 'object'
    or pg_catalog.octet_length(p_value::text) > 16384
    or public.conversational_rectification_numbers_are_stable(p_value) is not true
    or not public.conversational_rectification_has_only_keys(
      p_value,
      array[
        'id', 'rawText', 'domain', 'eventSummary', 'dateValue',
        'datePrecision', 'extractionStatus', 'scoreable', 'correctsEvidenceIds'
      ]::text[]
    )
    or not (p_value ?& array[
      'id', 'rawText', 'domain', 'eventSummary', 'dateValue',
      'datePrecision', 'extractionStatus'
    ]::text[])
    or pg_catalog.jsonb_typeof(p_value -> 'id') is distinct from 'string'
    or not public.conversational_rectification_valid_uuid_text(p_value ->> 'id')
    or p_value ->> 'id' !~* '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
    or pg_catalog.jsonb_typeof(p_value -> 'rawText') is distinct from 'string'
    or public.conversational_rectification_text_utf16_length(
      p_value ->> 'rawText'
    ) not between 1 and 4000
    or public.conversational_rectification_text_is_nonblank(
      p_value ->> 'rawText'
    ) is not true
    or pg_catalog.jsonb_typeof(p_value -> 'domain') is distinct from 'string'
    or p_value ->> 'domain' not in (
      'career', 'education', 'relocation', 'relationship', 'family', 'other'
    )
    or pg_catalog.jsonb_typeof(p_value -> 'eventSummary') is distinct from 'string'
    or public.conversational_rectification_text_utf16_length(
      p_value ->> 'eventSummary'
    ) not between 1 and 1000
    or public.conversational_rectification_text_is_nonblank(
      p_value ->> 'eventSummary'
    ) is not true
    or not (p_value ? 'dateValue')
    or (
      p_value -> 'dateValue' <> 'null'::jsonb
      and (
        pg_catalog.jsonb_typeof(p_value -> 'dateValue') is distinct from 'string'
        or public.conversational_rectification_text_utf16_length(
          p_value ->> 'dateValue'
        ) not between 1 and 80
        or public.conversational_rectification_text_is_nonblank(
          p_value ->> 'dateValue'
        ) is not true
      )
    )
    or pg_catalog.jsonb_typeof(p_value -> 'datePrecision') is distinct from 'string'
    or p_value ->> 'datePrecision' not in ('day', 'month', 'year', 'range', 'unknown')
    or pg_catalog.jsonb_typeof(p_value -> 'extractionStatus') is distinct from 'string'
    or p_value ->> 'extractionStatus' not in (
      'clear', 'needs_clarification', 'corrected'
    )
    or (
      p_value ? 'scoreable'
      and pg_catalog.jsonb_typeof(p_value -> 'scoreable') is distinct from 'boolean'
    )
    or (
      p_value ? 'correctsEvidenceIds'
      and (
        pg_catalog.jsonb_typeof(p_value -> 'correctsEvidenceIds') is distinct from 'array'
        or pg_catalog.octet_length((p_value -> 'correctsEvidenceIds')::text) > 64
        or pg_catalog.jsonb_array_length(p_value -> 'correctsEvidenceIds') > 1
        or exists (
          select 1
          from pg_catalog.jsonb_array_elements(p_value -> 'correctsEvidenceIds') target
          where pg_catalog.jsonb_typeof(target) is distinct from 'string'
            or public.conversational_rectification_valid_uuid_text(target #>> '{}') is not true
        )
      )
    )
    or (
      p_value ->> 'extractionStatus' = 'corrected'
      and (
        not (p_value ? 'correctsEvidenceIds')
        or pg_catalog.jsonb_array_length(p_value -> 'correctsEvidenceIds') <> 1
      )
    )
    or (
      p_value ->> 'extractionStatus' = 'clear'
      and p_value ? 'correctsEvidenceIds'
      and pg_catalog.jsonb_array_length(p_value -> 'correctsEvidenceIds') <> 0
    ) then
    return false;
  end if;
  return true;
exception when others then
  return false;
end;
$$;

create or replace function public.conversational_rectification_valid_life_event_evidence_array(
  p_value jsonb
)
returns boolean
language plpgsql
immutable
strict
set search_path = ''
as $$
declare
  v_item jsonb;
begin
  if pg_catalog.jsonb_typeof(p_value) is distinct from 'array'
    or pg_catalog.jsonb_array_length(p_value) > 20 then
    return false;
  end if;
  for v_item in select value from pg_catalog.jsonb_array_elements(p_value) loop
    if public.conversational_rectification_valid_life_event_evidence(v_item) is not true then
      return false;
    end if;
  end loop;
  return true;
exception when others then
  return false;
end;
$$;

create or replace function public.conversational_rectification_valid_private_candidate(
  p_value jsonb
)
returns boolean
language plpgsql
immutable
strict
set search_path = ''
as $$
declare
  v_item jsonb;
  v_key text;
begin
  if pg_catalog.jsonb_typeof(p_value) is distinct from 'object'
    or pg_catalog.octet_length(p_value::text) > 65536
    or public.conversational_rectification_numbers_are_stable(p_value) is not true
    or not public.conversational_rectification_has_only_keys(
      p_value,
      array[
        'resultId', 'representativeTime', 'rangeStart', 'rangeEnd',
        'calculationVersion', 'candidateWeights', 'candidateModelRefs',
        'd1Stability', 'boundaryDistanceMinutes', 'supportedSensitiveLayers',
        'scoredHistoricalEvidence', 'suggestedDomains', 'futureWindows', 'workingState'
      ]::text[]
    )
    or not (p_value ? 'calculationVersion')
    or pg_catalog.jsonb_typeof(p_value -> 'calculationVersion') is distinct from 'string'
    or public.conversational_rectification_text_utf16_length(
      p_value ->> 'calculationVersion'
    ) not between 1 and 80
    or public.conversational_rectification_text_is_nonblank(
      p_value ->> 'calculationVersion'
    ) is not true then
    return false;
  end if;
  if p_value ? 'resultId' and p_value -> 'resultId' <> 'null'::jsonb and (
    pg_catalog.jsonb_typeof(p_value -> 'resultId') is distinct from 'string'
    or not public.conversational_rectification_valid_uuid_text(p_value ->> 'resultId')
  ) then return false; end if;
  foreach v_key in array array['representativeTime', 'rangeStart', 'rangeEnd']::text[] loop
    if p_value ? v_key and p_value -> v_key <> 'null'::jsonb and (
      pg_catalog.jsonb_typeof(p_value -> v_key) is distinct from 'string'
      or not public.conversational_rectification_valid_time_text(p_value ->> v_key)
    ) then return false; end if;
  end loop;
  if (p_value ? 'rangeStart') <> (p_value ? 'rangeEnd')
    or (p_value -> 'rangeStart' = 'null'::jsonb) <> (p_value -> 'rangeEnd' = 'null'::jsonb) then
    return false;
  end if;
  if p_value ? 'candidateWeights' and (
    pg_catalog.jsonb_typeof(p_value -> 'candidateWeights') is distinct from 'array'
    or pg_catalog.jsonb_array_length(p_value -> 'candidateWeights') > 1440
    or exists (
      select 1 from pg_catalog.jsonb_array_elements(p_value -> 'candidateWeights') weight
      where pg_catalog.jsonb_typeof(weight) <> 'number'
        or (weight #>> '{}')::numeric not between 0 and 1
    )
  ) then return false; end if;
  if p_value ? 'candidateModelRefs' and not public.conversational_rectification_text_array_is_bounded(
    p_value -> 'candidateModelRefs', 80, 120, 16384
  ) then return false; end if;
  if p_value ? 'supportedSensitiveLayers' and not public.conversational_rectification_text_array_is_bounded(
    p_value -> 'supportedSensitiveLayers', 40, 80, 8192
  ) then return false; end if;
  if p_value ? 'd1Stability' and p_value ->> 'd1Stability' not in (
    'stable', 'sensitive', 'unavailable'
  ) then return false; end if;
  if p_value ? 'd1Stability'
    and pg_catalog.jsonb_typeof(p_value -> 'd1Stability') is distinct from 'string' then
    return false;
  end if;
  if p_value ? 'boundaryDistanceMinutes' and p_value -> 'boundaryDistanceMinutes' <> 'null'::jsonb and (
    pg_catalog.jsonb_typeof(p_value -> 'boundaryDistanceMinutes') is distinct from 'number'
    or p_value ->> 'boundaryDistanceMinutes' !~ '^[0-9]+$'
    or (p_value ->> 'boundaryDistanceMinutes')::integer not between 0 and 1440
  ) then return false; end if;
  if p_value ? 'suggestedDomains' and (
    pg_catalog.jsonb_typeof(p_value -> 'suggestedDomains') is distinct from 'array'
    or pg_catalog.jsonb_array_length(p_value -> 'suggestedDomains') > 6
    or exists (
      select 1 from pg_catalog.jsonb_array_elements(p_value -> 'suggestedDomains') domain
      where pg_catalog.jsonb_typeof(domain) is distinct from 'string'
        or domain #>> '{}' not in (
          'career', 'education', 'relocation', 'relationship', 'family', 'other'
        )
    )
  ) then return false; end if;
  if p_value ? 'scoredHistoricalEvidence' then
    if pg_catalog.jsonb_typeof(p_value -> 'scoredHistoricalEvidence') is distinct from 'array'
      or pg_catalog.jsonb_array_length(p_value -> 'scoredHistoricalEvidence') > 100 then
      return false;
    end if;
    for v_item in select value from pg_catalog.jsonb_array_elements(p_value -> 'scoredHistoricalEvidence') loop
      if pg_catalog.jsonb_typeof(v_item) is distinct from 'object'
        or pg_catalog.octet_length(v_item::text) > 8192
        or not public.conversational_rectification_has_only_keys(
          v_item, array['evidenceId', 'domain', 'candidateTime', 'score', 'ruleRefs']::text[]
        )
        or not (v_item ?& array['evidenceId', 'domain', 'candidateTime', 'score', 'ruleRefs']::text[])
        or pg_catalog.jsonb_typeof(v_item -> 'evidenceId') is distinct from 'string'
        or not public.conversational_rectification_valid_uuid_text(v_item ->> 'evidenceId')
        or pg_catalog.jsonb_typeof(v_item -> 'domain') is distinct from 'string'
        or v_item ->> 'domain' not in ('career', 'education', 'relocation', 'relationship', 'family', 'other')
        or (v_item -> 'candidateTime' <> 'null'::jsonb and (
          pg_catalog.jsonb_typeof(v_item -> 'candidateTime') is distinct from 'string'
          or not public.conversational_rectification_valid_time_text(v_item ->> 'candidateTime')
        ))
        or pg_catalog.jsonb_typeof(v_item -> 'score') is distinct from 'number'
        or (v_item ->> 'score')::numeric not between -1000000 and 1000000
        or not public.conversational_rectification_text_array_is_bounded(
          v_item -> 'ruleRefs', 40, 120, 8192
        ) then return false; end if;
    end loop;
  end if;
  if p_value ? 'futureWindows' then
    if pg_catalog.jsonb_typeof(p_value -> 'futureWindows') is distinct from 'array'
      or pg_catalog.jsonb_array_length(p_value -> 'futureWindows') > 20 then return false; end if;
    for v_item in select value from pg_catalog.jsonb_array_elements(p_value -> 'futureWindows') loop
      if pg_catalog.jsonb_typeof(v_item) is distinct from 'object'
        or pg_catalog.octet_length(v_item::text) > 2048
        or not public.conversational_rectification_has_only_keys(
          v_item, array['label', 'startDate', 'endDate', 'scoreable']::text[]
        )
        or not (v_item ?& array['label', 'startDate', 'endDate', 'scoreable']::text[])
        or pg_catalog.jsonb_typeof(v_item -> 'label') is distinct from 'string'
        or public.conversational_rectification_text_utf16_length(
          v_item ->> 'label'
        ) not between 1 and 240
        or public.conversational_rectification_text_is_nonblank(
          v_item ->> 'label'
        ) is not true
        or pg_catalog.jsonb_typeof(v_item -> 'startDate') is distinct from 'string'
        or pg_catalog.jsonb_typeof(v_item -> 'endDate') is distinct from 'string'
        or not public.conversational_rectification_valid_date_text(v_item ->> 'startDate')
        or not public.conversational_rectification_valid_date_text(v_item ->> 'endDate')
        or v_item ->> 'startDate' > v_item ->> 'endDate'
        or v_item -> 'scoreable' <> 'false'::jsonb then return false; end if;
    end loop;
  end if;
  if p_value ? 'workingState' then
    v_item := p_value -> 'workingState';
    if pg_catalog.jsonb_typeof(v_item) is distinct from 'object'
      or pg_catalog.octet_length(v_item::text) > 8192
      or not public.conversational_rectification_has_only_keys(
        v_item, array['phase', 'iteration', 'notes']::text[]
      )
      or not (v_item ?& array['phase', 'iteration', 'notes']::text[])
      or pg_catalog.jsonb_typeof(v_item -> 'phase') is distinct from 'string'
      or v_item ->> 'phase' not in ('initial', 'collecting_evidence', 'rescoring', 'ready', 'confirmed')
      or pg_catalog.jsonb_typeof(v_item -> 'iteration') is distinct from 'number'
      or v_item ->> 'iteration' !~ '^[0-9]+$'
      or (v_item ->> 'iteration')::integer not between 0 and 100
      or not public.conversational_rectification_text_array_is_bounded(
        v_item -> 'notes', 20, 240, 8192
      ) then return false; end if;
  end if;
  return true;
exception when others then
  return false;
end;
$$;

create or replace function public.conversational_rectification_valid_declared_birth_input(
  p_value jsonb
)
returns boolean
language plpgsql
immutable
strict
set search_path = ''
as $$
declare
  v_place jsonb;
  v_source text;
  v_key text;
  v_before integer;
  v_after integer;
begin
  if pg_catalog.jsonb_typeof(p_value) is distinct from 'object'
    or pg_catalog.octet_length(p_value::text) > 12000
    or public.conversational_rectification_numbers_are_stable(p_value) is not true
    or not public.conversational_rectification_has_only_keys(
      p_value,
      array[
        'birthDate', 'source', 'birthTimeClue', 'birthplace', 'reportedTime',
        'reportedPeriod', 'uncertaintyBeforeMinutes', 'uncertaintyAfterMinutes'
      ]::text[]
    )
    or not (p_value ?& array['birthDate', 'source', 'birthTimeClue', 'birthplace']::text[])
    or pg_catalog.jsonb_typeof(p_value -> 'birthDate') is distinct from 'string'
    or not public.conversational_rectification_valid_date_text(p_value ->> 'birthDate')
    or pg_catalog.jsonb_typeof(p_value -> 'source') is distinct from 'string'
    or public.conversational_rectification_text_is_nonblank(
      p_value ->> 'source'
    ) is not true
    or p_value -> 'birthTimeClue' <> 'null'::jsonb and (
      pg_catalog.jsonb_typeof(p_value -> 'birthTimeClue') is distinct from 'string'
      or public.conversational_rectification_text_utf16_length(
        p_value ->> 'birthTimeClue'
      ) not between 1 and 240
      or public.conversational_rectification_text_is_nonblank(
        p_value ->> 'birthTimeClue'
      ) is not true
    ) then return false; end if;

  v_place := p_value -> 'birthplace';
  if pg_catalog.jsonb_typeof(v_place) is distinct from 'object'
    or pg_catalog.octet_length(v_place::text) > 4096
    or not public.conversational_rectification_has_only_keys(
      v_place,
      array[
        'city', 'countryCode', 'provinceCode', 'cityCode', 'districtCode',
        'latitude', 'longitude', 'timezoneOffset'
      ]::text[]
    )
    or not (v_place ? 'timezoneOffset')
    or not ((v_place ? 'city') or (v_place ? 'cityCode'))
    or pg_catalog.jsonb_typeof(v_place -> 'timezoneOffset') is distinct from 'number'
    or (v_place ->> 'timezoneOffset')::numeric not between -12 and 14
    or (v_place ? 'latitude') <> (v_place ? 'longitude') then return false; end if;
  foreach v_key in array array['city', 'provinceCode', 'cityCode', 'districtCode']::text[] loop
    if v_place ? v_key and (
      pg_catalog.jsonb_typeof(v_place -> v_key) is distinct from 'string'
      or public.conversational_rectification_text_utf16_length(
        v_place ->> v_key
      ) not between 1 and
        case when v_key = 'city' then 120 else 80 end
      or public.conversational_rectification_text_is_nonblank(
        v_place ->> v_key
      ) is not true
    ) then return false; end if;
  end loop;
  if v_place ? 'countryCode' and (
    pg_catalog.jsonb_typeof(v_place -> 'countryCode') is distinct from 'string'
    or v_place ->> 'countryCode' !~ '^[A-Z0-9-]{1,8}$'
  ) then return false; end if;
  if v_place ? 'latitude' and (
    pg_catalog.jsonb_typeof(v_place -> 'latitude') is distinct from 'number'
    or pg_catalog.jsonb_typeof(v_place -> 'longitude') is distinct from 'number'
    or (v_place ->> 'latitude')::numeric not between -90 and 90
    or (v_place ->> 'longitude')::numeric not between -180 and 180
  ) then return false; end if;

  v_source := p_value ->> 'source';
  if v_source not in (
    'hospital_record', 'family_exact', 'approximate', 'period_only', 'unknown', 'legacy_import'
  ) then return false; end if;
  if p_value ? 'reportedTime' and (
    pg_catalog.jsonb_typeof(p_value -> 'reportedTime') is distinct from 'string'
    or not public.conversational_rectification_valid_time_text(p_value ->> 'reportedTime')
  ) then return false; end if;
  if p_value ? 'reportedPeriod' and (
    pg_catalog.jsonb_typeof(p_value -> 'reportedPeriod') is distinct from 'string'
    or p_value ->> 'reportedPeriod' not in (
      'early_morning', 'morning', 'afternoon', 'evening', 'late_night'
    )
  ) then return false; end if;
  if p_value ? 'uncertaintyBeforeMinutes' then
    if pg_catalog.jsonb_typeof(p_value -> 'uncertaintyBeforeMinutes') is distinct from 'number'
      or pg_catalog.jsonb_typeof(p_value -> 'uncertaintyAfterMinutes') is distinct from 'number'
      or p_value ->> 'uncertaintyBeforeMinutes' !~ '^[0-9]+$'
      or p_value ->> 'uncertaintyAfterMinutes' !~ '^[0-9]+$' then
      return false;
    end if;
    v_before := (p_value ->> 'uncertaintyBeforeMinutes')::integer;
    v_after := (p_value ->> 'uncertaintyAfterMinutes')::integer;
  elsif p_value ? 'uncertaintyAfterMinutes' then
    return false;
  end if;

  if v_source = 'hospital_record' then
    return p_value ? 'reportedTime'
      and not (p_value ? 'reportedPeriod')
      and v_before = 2 and v_after = 2;
  elsif v_source = 'family_exact' then
    return p_value ? 'reportedTime'
      and not (p_value ? 'reportedPeriod')
      and v_before = v_after and v_before in (5, 10, 15);
  elsif v_source = 'approximate' then
    return p_value ? 'reportedTime'
      and not (p_value ? 'reportedPeriod')
      and v_before = v_after and v_before in (15, 30, 60);
  elsif v_source = 'period_only' then
    return p_value ? 'reportedPeriod'
      and not (p_value ? 'reportedTime')
      and not (p_value ? 'uncertaintyBeforeMinutes')
      and not (p_value ? 'uncertaintyAfterMinutes');
  elsif v_source = 'unknown' then
    return not (p_value ? 'reportedPeriod')
      and not (p_value ? 'reportedTime')
      and not (p_value ? 'uncertaintyBeforeMinutes')
      and not (p_value ? 'uncertaintyAfterMinutes');
  end if;
  return not ((p_value ? 'reportedTime') and (p_value ? 'reportedPeriod'))
    and ((p_value ? 'reportedTime') or v_before is null)
    and (v_before is null or (v_before between 0 and 720 and v_after between 0 and 720));
exception when others then
  return false;
end;
$$;

create or replace function public.conversational_rectification_valid_public_turn(p_value jsonb)
returns boolean
language sql
immutable
strict
set search_path = ''
as $$
  select pg_catalog.jsonb_typeof(p_value) = 'object'
    and pg_catalog.octet_length(p_value::text) <= 65536
    and public.conversational_rectification_numbers_are_stable(p_value)
    and public.conversational_rectification_has_only_keys(
      p_value,
      array[
        'caseId', 'journeyProtocol', 'status', 'turnVersion', 'narrative',
        'candidate', 'technicalReceipt', 'evidenceRequest', 'evidenceRecap',
        'actions', 'pendingConsultationQuestion'
      ]::text[]
    )
    and p_value ?& array[
      'caseId', 'journeyProtocol', 'status', 'turnVersion', 'narrative',
      'candidate', 'technicalReceipt', 'evidenceRequest', 'evidenceRecap',
      'actions', 'pendingConsultationQuestion'
    ]::text[]
    and pg_catalog.jsonb_typeof(p_value -> 'caseId') = 'string'
    and public.conversational_rectification_valid_uuid_text(p_value ->> 'caseId')
    and pg_catalog.jsonb_typeof(p_value -> 'journeyProtocol') = 'string'
    and p_value ->> 'journeyProtocol' = 'conversational-evidence-v3'
    and pg_catalog.jsonb_typeof(p_value -> 'status') = 'string'
    and p_value ->> 'status' in ('active', 'paused', 'confirming', 'completed', 'abandoned')
    and pg_catalog.jsonb_typeof(p_value -> 'turnVersion') = 'number'
    and p_value ->> 'turnVersion' ~ '^[0-9]+$'
    and pg_catalog.jsonb_typeof(p_value -> 'narrative') = 'string'
    and public.conversational_rectification_text_utf16_length(
      p_value ->> 'narrative'
    ) between 1 and 12000
    and public.conversational_rectification_text_is_nonblank(
      p_value ->> 'narrative'
    )
    and public.conversational_rectification_valid_candidate(p_value -> 'candidate')
    and public.conversational_rectification_valid_technical_receipt(p_value -> 'technicalReceipt')
    and (
      p_value -> 'evidenceRequest' = 'null'::jsonb
      or public.conversational_rectification_valid_evidence_request(p_value -> 'evidenceRequest')
    )
    and public.conversational_rectification_valid_evidence_recap(p_value -> 'evidenceRecap')
    and public.conversational_rectification_valid_actions(p_value -> 'actions')
    and (
      p_value -> 'pendingConsultationQuestion' = 'null'::jsonb
      or (
        pg_catalog.jsonb_typeof(p_value -> 'pendingConsultationQuestion') = 'string'
        and public.conversational_rectification_text_utf16_length(
          p_value ->> 'pendingConsultationQuestion'
        ) between 1 and 500
        and public.conversational_rectification_text_is_nonblank(
          p_value ->> 'pendingConsultationQuestion'
        )
      )
    );
$$;

create or replace function public.conversational_rectification_valid_action_request(p_value jsonb)
returns boolean
language sql
immutable
strict
set search_path = ''
as $$
  select pg_catalog.jsonb_typeof(p_value) = 'object'
    and pg_catalog.octet_length(p_value::text) <= 2048
    and public.conversational_rectification_numbers_are_stable(p_value)
    and public.conversational_rectification_has_only_keys(
      p_value,
      array[
        'kind', 'userId', 'caseId', 'expectedVersion', 'actionId',
        'requestFingerprint', 'commandFingerprint'
      ]::text[]
    )
    and p_value ?& array[
      'kind', 'userId', 'caseId', 'expectedVersion', 'actionId', 'requestFingerprint'
    ]::text[]
    and pg_catalog.jsonb_typeof(p_value -> 'kind') = 'string'
    and p_value ->> 'kind' in (
      'create', 'save_turn', 'pause', 'abandon', 'confirm', 'import_legacy',
      'reserve_fee', 'complete_fee', 'release_fee', 'recover_fee'
    )
    and pg_catalog.jsonb_typeof(p_value -> 'userId') = 'string'
    and public.conversational_rectification_valid_uuid_text(p_value ->> 'userId')
    and pg_catalog.jsonb_typeof(p_value -> 'caseId') = 'string'
    and public.conversational_rectification_valid_uuid_text(p_value ->> 'caseId')
    and pg_catalog.jsonb_typeof(p_value -> 'actionId') = 'string'
    and public.conversational_rectification_valid_uuid_text(p_value ->> 'actionId')
    and pg_catalog.jsonb_typeof(p_value -> 'expectedVersion') = 'number'
    and p_value ->> 'expectedVersion' ~ '^[0-9]+$'
    and pg_catalog.jsonb_typeof(p_value -> 'requestFingerprint') = 'string'
    and p_value ->> 'requestFingerprint' ~ '^[0-9a-f]{64}$'
    and (
      not (p_value ? 'commandFingerprint')
      or (
        pg_catalog.jsonb_typeof(p_value -> 'commandFingerprint') = 'string'
        and p_value ->> 'commandFingerprint' ~ '^[0-9a-f]{64}$'
      )
    );
$$;

create or replace function public.conversational_rectification_action_request(
  p_kind text,
  p_user_id uuid,
  p_case_id uuid,
  p_expected_version bigint,
  p_action_id uuid,
  p_request_fingerprint text
)
returns jsonb
language sql
immutable
strict
set search_path = ''
as $$
  select pg_catalog.jsonb_build_object(
    'kind', p_kind,
    'userId', p_user_id,
    'caseId', p_case_id,
    'expectedVersion', p_expected_version,
    'actionId', p_action_id,
    'requestFingerprint', p_request_fingerprint
  );
$$;

create or replace function public.conversational_rectification_valid_action_response(
  p_value jsonb,
  p_action_kind text
)
returns boolean
language plpgsql
immutable
strict
set search_path = ''
as $$
begin
  if p_action_kind in ('reserve_fee', 'complete_fee', 'release_fee', 'recover_fee') then
    return coalesce(pg_catalog.jsonb_typeof(p_value) = 'object'
      and pg_catalog.octet_length(p_value::text) <= 2048
      and public.conversational_rectification_numbers_are_stable(p_value)
      and public.conversational_rectification_has_only_keys(
        p_value, array['success', 'credits', 'billing_state', 'error_code']::text[]
      )
      and p_value ?& array['success', 'credits', 'billing_state', 'error_code']::text[]
      and pg_catalog.jsonb_typeof(p_value -> 'success') = 'boolean'
      and (
        p_value -> 'credits' = 'null'::jsonb
        or (
          pg_catalog.jsonb_typeof(p_value -> 'credits') = 'number'
          and p_value ->> 'credits' ~ '^[0-9]+$'
        )
      )
      and (
        p_value -> 'billing_state' = 'null'::jsonb
        or (
          pg_catalog.jsonb_typeof(p_value -> 'billing_state') = 'string'
          and p_value ->> 'billing_state' in (
            'reserved', 'charged', 'released', 'migration_waived'
          )
        )
      )
      and (
        p_value -> 'error_code' = 'null'::jsonb
        or (
          pg_catalog.jsonb_typeof(p_value -> 'error_code') = 'string'
          and public.conversational_rectification_text_utf16_length(
            p_value ->> 'error_code'
          ) between 1 and 80
          and public.conversational_rectification_text_is_nonblank(
            p_value ->> 'error_code'
          )
        )
      ), false);
  end if;
  return coalesce(pg_catalog.jsonb_typeof(p_value) = 'object'
    and pg_catalog.octet_length(p_value::text) <= 69632
    and public.conversational_rectification_numbers_are_stable(p_value)
    and public.conversational_rectification_has_only_keys(
      p_value,
      array[
        'case_id', 'user_id', 'status', 'turn_version', 'revision_of_case_id',
        'imported_from_case_id', 'baseline_active_time', 'pending_consultation_question',
        'billing_state', 'latest_turn'
      ]::text[]
    )
    and p_value ?& array[
      'case_id', 'user_id', 'status', 'turn_version', 'revision_of_case_id',
      'imported_from_case_id', 'baseline_active_time', 'pending_consultation_question',
      'billing_state', 'latest_turn'
    ]::text[]
    and pg_catalog.jsonb_typeof(p_value -> 'case_id') = 'string'
    and public.conversational_rectification_valid_uuid_text(p_value ->> 'case_id')
    and pg_catalog.jsonb_typeof(p_value -> 'user_id') = 'string'
    and public.conversational_rectification_valid_uuid_text(p_value ->> 'user_id')
    and pg_catalog.jsonb_typeof(p_value -> 'status') = 'string'
    and p_value ->> 'status' in ('starting', 'active', 'paused', 'confirming', 'completed', 'abandoned')
    and pg_catalog.jsonb_typeof(p_value -> 'turn_version') = 'number'
    and p_value ->> 'turn_version' ~ '^[0-9]+$'
    and (p_value -> 'revision_of_case_id' = 'null'::jsonb
      or (pg_catalog.jsonb_typeof(p_value -> 'revision_of_case_id') = 'string'
        and public.conversational_rectification_valid_uuid_text(
          p_value ->> 'revision_of_case_id'
        )))
    and (p_value -> 'imported_from_case_id' = 'null'::jsonb
      or (pg_catalog.jsonb_typeof(p_value -> 'imported_from_case_id') = 'string'
        and public.conversational_rectification_valid_uuid_text(
          p_value ->> 'imported_from_case_id'
        )))
    and (p_value -> 'baseline_active_time' = 'null'::jsonb
      or (pg_catalog.jsonb_typeof(p_value -> 'baseline_active_time') = 'string'
        and public.conversational_rectification_valid_time_text(
          p_value ->> 'baseline_active_time'
        )))
    and (p_value -> 'pending_consultation_question' = 'null'::jsonb
      or (pg_catalog.jsonb_typeof(p_value -> 'pending_consultation_question') = 'string'
        and public.conversational_rectification_text_utf16_length(
          p_value ->> 'pending_consultation_question'
        ) between 1 and 500
        and public.conversational_rectification_text_is_nonblank(
          p_value ->> 'pending_consultation_question'
        )))
    and (p_value -> 'billing_state' = 'null'::jsonb
      or (pg_catalog.jsonb_typeof(p_value -> 'billing_state') = 'string'
        and p_value ->> 'billing_state' in (
          'reserved', 'charged', 'released', 'migration_waived'
        )))
    and public.conversational_rectification_valid_public_turn(p_value -> 'latest_turn'), false);
exception when others then
  return false;
end;
$$;

alter table public.birth_time_rectification_cases
  add column if not exists revision_of_case_id uuid,
  add column if not exists imported_from_case_id uuid,
  add column if not exists baseline_active_time time without time zone,
  add column if not exists pending_consultation_question text,
  add column if not exists declared_birth_input jsonb not null default '{}'::jsonb;

alter table public.birth_time_rectification_cases
  drop constraint if exists birth_time_rectification_cases_revision_of_case_id_fkey,
  drop constraint if exists birth_time_rectification_cases_imported_from_case_id_fkey,
  drop constraint if exists birth_time_rectification_cases_pending_question_check,
  drop constraint if exists birth_time_rectification_cases_declared_birth_input_check,
  drop constraint if exists birth_time_rectification_cases_private_candidate_v3_check,
  drop constraint if exists birth_time_rectification_cases_turn_state_v3_check,
  drop constraint if exists birth_time_rectification_cases_journey_snapshot_v3_check,
  drop constraint if exists birth_time_rectification_cases_journey_protocol_check,
  drop constraint if exists birth_time_rectification_cases_status_check;

alter table public.birth_time_rectification_cases
  add constraint birth_time_rectification_cases_revision_of_case_id_fkey
    foreign key (revision_of_case_id)
    references public.birth_time_rectification_cases(id) on delete set null,
  add constraint birth_time_rectification_cases_imported_from_case_id_fkey
    foreign key (imported_from_case_id)
    references public.birth_time_rectification_cases(id) on delete set null,
  add constraint birth_time_rectification_cases_pending_question_check
    check (
      pending_consultation_question is null
      or (
        public.conversational_rectification_text_utf16_length(
          pending_consultation_question
        ) between 1 and 500
        and public.conversational_rectification_text_is_nonblank(
          pending_consultation_question
        )
      )
    ),
  add constraint birth_time_rectification_cases_declared_birth_input_check
    check (
      jsonb_typeof(declared_birth_input) = 'object'
      and octet_length(declared_birth_input::text) <= 12000
      and (
        journey_protocol <> 'conversational-evidence-v3'
        or public.conversational_rectification_valid_declared_birth_input(declared_birth_input) is true
      )
    ),
  add constraint birth_time_rectification_cases_private_candidate_v3_check
    check (
      journey_protocol <> 'conversational-evidence-v3'
      or public.conversational_rectification_valid_private_candidate(candidate_result) is true
    ),
  add constraint birth_time_rectification_cases_turn_state_v3_check
    check (
      journey_protocol <> 'conversational-evidence-v3'
      or public.conversational_rectification_valid_public_turn(turn_state) is true
    ),
  add constraint birth_time_rectification_cases_journey_snapshot_v3_check
    check (
      journey_protocol <> 'conversational-evidence-v3'
      or public.conversational_rectification_valid_public_turn(journey_snapshot) is true
    ),
  add constraint birth_time_rectification_cases_journey_protocol_check
    check (journey_protocol in (
      'legacy-guided-v1',
      'dynamic-choice-v2',
      'conversational-evidence-v3'
    )),
  add constraint birth_time_rectification_cases_status_check
    check (status in (
      'assessing', 'rectifying', 'candidate', 'confirming', 'confirmed',
      'starting', 'active', 'paused', 'completed', 'abandoned'
    ));

-- Billing and case creation are phases of one public start action. Billing
-- phases use deterministic internal receipt ids so the public action can stay
-- stable without colliding with the case-transition receipt key.
create or replace function public.conversational_rectification_billing_receipt_action_id(
  p_action_id uuid,
  p_action_kind text
)
returns uuid
language sql
immutable
strict
set search_path = ''
as $$
  select pg_catalog.md5(p_action_id::text || ':' || p_action_kind)::uuid;
$$;

create table if not exists public.birth_time_rectification_turns (
  id uuid not null default gen_random_uuid(),
  case_id uuid not null
    references public.birth_time_rectification_cases(id) on delete cascade,
  turn_version bigint not null check (turn_version >= 0),
  narrative text not null check (
    public.conversational_rectification_text_utf16_length(narrative) between 1 and 12000
    and public.conversational_rectification_text_is_nonblank(narrative)
  ),
  candidate jsonb not null check (
    public.conversational_rectification_valid_candidate(candidate) is true
  ),
  technical_receipt jsonb not null check (
    public.conversational_rectification_valid_technical_receipt(technical_receipt) is true
  ),
  evidence_request jsonb check (
    evidence_request is null
    or public.conversational_rectification_valid_evidence_request(evidence_request) is true
  ),
  evidence_recap jsonb not null default '[]'::jsonb check (
    public.conversational_rectification_valid_evidence_recap(evidence_recap) is true
  ),
  actions jsonb not null default '[]'::jsonb check (
    public.conversational_rectification_valid_actions(actions) is true
  ),
  output_validation_receipt jsonb not null check (
    public.conversational_rectification_valid_validation_receipt(output_validation_receipt) is true
  ),
  created_at timestamptz not null default now(),
  primary key (case_id, turn_version),
  unique (case_id, id),
  check (not jsonb_path_exists(
    jsonb_build_object(
      'candidate', candidate,
      'technicalReceipt', technical_receipt,
      'evidenceRequest', evidence_request,
      'evidenceRecap', evidence_recap,
      'outputValidationReceipt', output_validation_receipt
    ),
    '$.**.candidateWeights'
  )),
  check (not jsonb_path_exists(candidate, '$.**.candidateScores')),
  check (not jsonb_path_exists(candidate, '$.**.partitionId')),
  check (not jsonb_path_exists(technical_receipt, '$.**.rawModelOutput')),
  check (not jsonb_path_exists(output_validation_receipt, '$.**.systemPrompt'))
);

create table if not exists public.birth_time_rectification_event_evidence (
  id uuid primary key default gen_random_uuid(),
  case_id uuid not null,
  source_turn_id uuid not null,
  raw_text text not null check (
    public.conversational_rectification_text_utf16_length(raw_text) between 1 and 4000
    and public.conversational_rectification_text_is_nonblank(raw_text)
  ),
  domain text not null check (
    domain in ('career', 'education', 'relocation', 'relationship', 'family', 'other')
  ),
  event_summary text not null check (
    public.conversational_rectification_text_utf16_length(event_summary) between 1 and 1000
    and public.conversational_rectification_text_is_nonblank(event_summary)
  ),
  date_value text check (
    date_value is null
    or (
      public.conversational_rectification_text_utf16_length(date_value) between 1 and 80
      and public.conversational_rectification_text_is_nonblank(date_value)
    )
  ),
  date_precision text not null check (
    date_precision in ('day', 'month', 'year', 'range', 'unknown')
  ),
  extraction_status text not null check (
    extraction_status in ('clear', 'needs_clarification', 'corrected')
  ),
  corrects_evidence_ids uuid[] not null default '{}'::uuid[] check (
    pg_catalog.cardinality(corrects_evidence_ids) <= 1
    and (
      (extraction_status = 'corrected' and pg_catalog.cardinality(corrects_evidence_ids) = 1)
      or (extraction_status = 'clear' and pg_catalog.cardinality(corrects_evidence_ids) = 0)
      or extraction_status = 'needs_clarification'
    )
  ),
  scoreable boolean not null default false,
  created_at timestamptz not null default now(),
  foreign key (case_id, source_turn_id)
    references public.birth_time_rectification_turns(case_id, id) on delete cascade
);

create table if not exists public.birth_time_rectification_action_receipts (
  -- Billing reservation happens before the case exists, so receipts cannot
  -- depend on the case row. The service-only RPCs preserve ownership.
  case_id uuid not null,
  action_id uuid not null,
  user_id uuid not null references auth.users(id) on delete cascade,
  action_kind text not null check (action_kind in (
    'create', 'save_turn', 'pause', 'abandon', 'confirm', 'import_legacy',
    'reserve_fee', 'complete_fee', 'release_fee', 'recover_fee'
  )),
  expected_turn_version bigint not null check (expected_turn_version >= 0),
  result_turn_version bigint not null check (result_turn_version >= 0),
  request_fingerprint text not null check (request_fingerprint ~ '^[0-9a-f]{64}$'),
  request jsonb not null check (
    public.conversational_rectification_valid_action_request(request) is true
  ),
  response jsonb not null check (
    public.conversational_rectification_valid_action_response(response, action_kind) is true
  ),
  created_at timestamptz not null default now(),
  primary key (case_id, action_id),
  check (not jsonb_path_exists(response, '$.**.candidateWeights')),
  check (not jsonb_path_exists(response, '$.**.candidateScores')),
  check (not jsonb_path_exists(response, '$.**.partitionId')),
  check (not jsonb_path_exists(response, '$.**.rawModelOutput')),
  check (not jsonb_path_exists(response, '$.**.systemPrompt'))
);

create table if not exists public.birth_time_rectification_billing (
  -- A reservation is the first durable start record and therefore precedes
  -- case creation. The case transition RPC claims this row atomically.
  case_id uuid primary key,
  user_id uuid not null references auth.users(id) on delete cascade,
  price integer not null check (price between 1 and 1000000),
  state text not null check (
    state in ('reserved', 'charged', 'released', 'migration_waived')
  ),
  reservation_id uuid unique,
  billing_receipt_id uuid unique,
  reserve_action_id uuid,
  complete_action_id uuid,
  release_action_id uuid,
  balance_after integer check (balance_after is null or balance_after >= 0),
  reserved_at timestamptz,
  charged_at timestamptz,
  released_at timestamptz,
  created_at timestamptz not null default now(),
  updated_at timestamptz not null default now(),
  check (
    state not in ('reserved', 'charged')
    or (reservation_id is not null and reserve_action_id is not null and reserved_at is not null)
  ),
  check (
    state <> 'charged'
    or (billing_receipt_id is not null and complete_action_id is not null and charged_at is not null)
  ),
  check (state <> 'released' or (release_action_id is not null and released_at is not null)),
  unique (user_id, reserve_action_id)
);

create index if not exists birth_time_rectification_cases_v3_account_idx
  on public.birth_time_rectification_cases (user_id, updated_at desc)
  where journey_protocol = 'conversational-evidence-v3';
create index if not exists birth_time_rectification_evidence_case_idx
  on public.birth_time_rectification_event_evidence (case_id, created_at);
create unique index if not exists birth_time_rectification_reserve_action_idx
  on public.birth_time_rectification_action_receipts (user_id, action_id)
  where action_kind = 'reserve_fee';

alter table public.birth_time_rectification_turns enable row level security;
alter table public.birth_time_rectification_event_evidence enable row level security;
alter table public.birth_time_rectification_action_receipts enable row level security;
alter table public.birth_time_rectification_billing enable row level security;

revoke all on table public.birth_time_rectification_cases from public, anon, authenticated;
revoke all on table public.birth_time_rectification_turns from public, anon, authenticated;
revoke all on table public.birth_time_rectification_event_evidence from public, anon, authenticated;
revoke all on table public.birth_time_rectification_action_receipts from public, anon, authenticated;
revoke all on table public.birth_time_rectification_billing from public, anon, authenticated;

revoke all on table public.birth_time_rectification_cases from service_role;
revoke all on table public.birth_time_rectification_turns from service_role;
revoke all on table public.birth_time_rectification_event_evidence from service_role;
revoke all on table public.birth_time_rectification_action_receipts from service_role;
revoke all on table public.birth_time_rectification_billing from service_role;

grant all on table public.birth_time_rectification_cases to service_role;
grant all on table public.birth_time_rectification_turns to service_role;
grant all on table public.birth_time_rectification_event_evidence to service_role;
grant all on table public.birth_time_rectification_action_receipts to service_role;
grant all on table public.birth_time_rectification_billing to service_role;

revoke all on function public.conversational_rectification_billing_receipt_action_id(
  uuid, text
) from public, anon, authenticated, service_role;
revoke all on function public.conversational_rectification_numbers_are_stable(jsonb)
  from public, anon, authenticated;
revoke all on function public.conversational_rectification_text_utf16_length(text)
  from public, anon, authenticated;
revoke all on function public.conversational_rectification_text_is_nonblank(text)
  from public, anon, authenticated;
revoke all on function public.conversational_rectification_valid_life_event_evidence(jsonb)
  from public, anon, authenticated;
revoke all on function public.conversational_rectification_valid_life_event_evidence_array(jsonb)
  from public, anon, authenticated;
grant execute on function public.conversational_rectification_numbers_are_stable(jsonb)
  to service_role;
grant execute on function public.conversational_rectification_text_utf16_length(text)
  to service_role;
grant execute on function public.conversational_rectification_text_is_nonblank(text)
  to service_role;
grant execute on function public.conversational_rectification_valid_life_event_evidence(jsonb)
  to service_role;
grant execute on function public.conversational_rectification_valid_life_event_evidence_array(jsonb)
  to service_role;

commit;