You are really working uphill by doing this all untyped, but you can get the value you want this way:

list<Object> l = (list<Object>) meta.get('addressDetails');
map<String,Object> m = (map<String,Object>) l[0];
Integer i = (Integer) m.get('addressId');

Honestly, if you make use of the Apex type system, you will have an easier time working with the data. If you create a class for the incoming data structure, abbreviated as:

public class Meta{
   public list<addressDetail> addressDetails {get; set;} 

   public class addressDetail{
       public Integer addressId {get; set;}
   }   
}

you will be able to access the data from your JSON strings as so:

Meta MyMeta = (Meta) JSON.deserialize(viewPersonValue,Meta.class);
system.debug(MyMeta.addressDetails[0].addressId);

You need to index into your list. Before you do so, however, you have to check if the list is empty.

for (Account record : [/*query*/])
{
    if (!record.Children__r.isEmpty())
        accountMap.put(record.AccountNumber, record.Children__r[0].Status__c);
}

If you omit the empty check, than any iteration over a record without an active child would throw this error:

System.ListException: List index out of bounds: 0

You cant convert the map to a list without an id. Alternatively why to convert it to List. Use the map itself. Below is a code example of how you can use it using your JSON response. For example, I want to insert this JSON response into the contact record, so I can map it using the MAP itself.:

@RestResource(urlMapping='/URIId/*') global class OwneriCRM {

@HttpPut
global static String UpdateOwnerinfo(){
    RestRequest req= RestContext.request;
    RestResponse res= RestContext.response;
    res.addHeader('Content-type','application/JSON');
    Map<String,Object> responseresult=new Map<String,Object>();
    Map<String,Object> results= (Map<String,Object>)JSON.deserializeUntyped(req.requestBody.toString());
     List<contact> insertList = new List<contact>();
    
    for (String key : results.keySet()){
    System.debug(results.get(key));
    contact c= new contact();
    c.ContactField__C = results.get(id);
    c.ContactField1__C = results.get(city);
    c.ContactField2__C = results.get(conference);
    c.ContactField3__C = results.get(division);
    c.ContactField3__C = results.get(full_name);
    c.ContactField3__C = results.get(name);
    insertList.add(c);
    
    }
    if(!insertList.Isempty()){
        update insertList;
    }

The problem is that key of your map is Id, is not String, you can see it from first debug message.

It looks like you're trying to call these methods from an Aura or LWC component. Presumably, these are two separate calls made by the component. Because the entire Lightning framework is a "stateless" environment, your static variable won't be remembered between the calls to getSiteIds and fetchSessions. Realistically, fetchSessions would need to call getSiteIds first, or you'd have to have your JavaScript send the appropriate data from the controller.

Looking in to this question, I realized that the type system is inherently broken. They have "fixed" Maps, it seems, but in a way that no longer lets you mix and match some types, especially Object.

The list class is still broken, however:

class c1 {

}
class c2 extends c1 {

}
c1[] s = new c2[0];

Generally speaking, unless/until they fix the problem, you won't be able to be polymorphic this way; your classes that intend to call this class would also need to use Map<Object, Object>, which will involve some casting.

One thought I had would be to create an interface like this:

public interface keyValueMap {
    Set<Object> getKeys();
    Object[] getValues();
    Object getKey(Object value);
    Object setKey(Object key, Object value);
}

And then create specific wrappers:

public class StringSObjectMap implements KeyValueMap {
    Map<String, SObject> values;
    public StringSObjectMap(Map<String, SObject> values) {
        this.values = values;
    }
    public StringSObjectMap() {
        values = new Map<String, SObject>();
    }
    public Set<Object> getKeys() {
        Set<Object> results = new Set<Object>();
        for(String value: values.keySet()) {
            results.add(value);
        }
        return results;
    }
    public Object[] getValues() {
        return (Object[])values.values();
    }
    public Object getKey(Object value) {
        return (Object)values.get((String)value);
    }
    public Object setKey(Object key, Object value) {
        return values.put((String)key, (SObject)value);
    }
}

Note that since we can't cast Set<SObject> to Set<Object>, we have to build a duplicate key set. Make sure you cache the results for performance reasons.

Finally, you can write your method to use the new interface:

public keyValueMap doSomething(keyValueMap inputMap) {

And to call it, you'd pass in the appropriate sub-wrapper:

keyValueMap results = doSomething(new StringSObjectMap(recordMap));

Depending on what you're doing, this may require additional post-processing to get the values back out.

You might also just leave the return type as Map<Object, Object> but you'll end up having to process the keys again, as demonstrated in the wrapper above. One additional step might help you here; you can pass in the type of return value you want:

public keyValueMap doSomething(keyValueMap inputMap, Type mapType) {
  keyValueMap results = (keyValueMap)mapType.newInstance();

Called as:

keyValueMap results = doSomething(new StringSObjectMap(recordMap), StringSObjectMap.class);

You could also create a custom Iterator, but this doesn't work in for-each loops (but you can use iter.next/iter.hasnext):

public class KeyValue {
  public Object key;
  public Object value;
  public KeyValue(Object k, Object v) {
    key = k;
    value = v;
  }
}

public class StringSObjectIter implements Iterable<KeyValue>, Iterator<KeyValue> {
    Map<String, SObject> values;
    String[] keys;
    public StringSObjectIter(Map<String, SObject> values) {
        this.values = values;
    }
    StringSObjectIter(StringSObjectIter copy) {
        values = copy.values;
        keys = new List<String>(values.keySet());
    }
    public Boolean hasNext() {
        return !keys.isEmpty();
    }
    public KeyValue next() {
        String k = keys.remove(0);
        return new KeyValue(k, values.get(k));
    }
    public Iterator<KeyValue> iterator() {
        return new StringSObjectIter(this);
    }
}

Which you can use in your method as:

public keyValueMap doSomething(Iterable<KeyValue> inputs) {
  Iterator<KeyValue> iter = inputs.iterator();
  while(iter.hasNext()) {
    KeyValue value = iter.next();
    ...

Calling method for this:

keyValueMap results = doSomething(new StringSObjectIter(recordMap));

So you can try like this

map<string,string> newMap= new Map<string,string>();
for(String strKey: mapValues.keyset())
{
    newMap.put(strKey, String.valueof(mapValues.get(strKey)));
}

RestContext.response.responseBody = Blob.valueOf(JSON.serialize(locations));

JSON can handle almost any data type, including maps that include serializable types. The exceptions to this rule are items that can't be serialized, like SavePoint, SObjectField and so on.