First, ensure you have access to your Azure Storage Account where your table storage is located. Obtain your account name and access key from the Azure portal. This information will be needed to authenticate and access your table data.

On your local development environment, install the Azure Storage SDK and the Typesense client library for your preferred programming language. For Python, you can use `azure-data-tables` for Azure Table Storage and `typesense` for Typesense. This can be done using pip:
```sh
pip install azure-data-tables typesense
```

Write a script to connect to your Azure Table Storage using the SDK. Initialize the `TableServiceClient` with your storage account credentials and access the specific table you want to migrate data from:
```python
from azure.data.tables import TableServiceClient

connection_string = "DefaultEndpointsProtocol=https;AccountName=your_account_name;AccountKey=your_account_key;TableEndpoint=your_table_endpoint;"
table_service_client = TableServiceClient.from_connection_string(conn_str=connection_string)
table_client = table_service_client.get_table_client(table_name="your_table_name")
```

Use your connection to retrieve data from the specified table. You can use queries to filter the data as needed. For fetching all records:
```python
entities = table_client.list_entities()
data = [entity for entity in entities]
```

Prepare the data for Typesense by transforming it into a format that Typesense can index. Typesense requires data to be in JSON format with specific field requirements as defined in your Typesense schema. Create a function to perform this transformation:
```python
def transform_data(entity):
return {
"id": entity['RowKey'],
"field1": entity.get('field1', ''),
"field2": entity.get('field2', ''),
# Add more fields as needed
}

transformed_data = [transform_data(entity) for entity in data]
```

Ensure your Typesense server is running and accessible. If not already done, set up a collection in Typesense with the appropriate schema. Use the Typesense client to create the collection if it does not exist:
```python
from typesense import Client

typesense_client = Client({
'nodes': [{
'host': 'localhost', # for Typesense Cloud use xxx.a1.typesense.net
'port': '8108', # for Typesense Cloud use 443
'protocol': 'http' # for Typesense Cloud use https
}],
'api_key': 'your_typesense_api_key',
})

collection_schema = {
"name": "your_collection_name",
"fields": [
{"name": "id", "type": "string"},
{"name": "field1", "type": "string"},
{"name": "field2", "type": "string"},
# Define additional fields based on your data
]
}

try:
typesense_client.collections.create(collection_schema)
except Exception as e:
print(f"Collection already exists or error: {e}")
```

Finally, index the transformed data into your Typesense collection. Use the `typesense` client to perform the indexing:
```python
try:
typesense_client.collections['your_collection_name'].documents.import_(transformed_data)
except Exception as e:
print(f"Error indexing data: {e}")
```

By following these steps, you can move data from Azure Table Storage to Typesense without relying on third-party connectors, ensuring a streamlined and controlled data migration process.