We are in the process of reorganizing our Lambda functions into a monorepo and utilizing shared resources (ApiGateway, IAM, S3) and want to us localstack to help with local development of our platform.  Unfortunately, we have seemed to run into a pretty big roadblock.

We are trying to share a single ApiGateway among multiple services.  We have a root service that defines and outputs the resource:

```yaml
resources:
  Resources:
    SharedGateway:
      Type: AWS::ApiGateway::RestApi
      Properties:
        Name: SharedGateway
  Outputs:
    apiGatewayRestApiId:
      Value:
        Ref: SharedGateway
      Export:
        Name: ${self:custom.stage}-SharedGateway-restApiId
    apiGatewayRestApiRootResourceId:
      Value:
        Fn::GetAtt:
          - SharedGateway
          - RootResourceId
      Export:
        Name: ${self:custom.stage}-SharedGateway-rootResourceId
```

When we deploy this function, the gateway is created as expected:

```json
❯ awslocal cloudformation describe-stacks                                                                                                                                                 
{
    "Stacks": [
        {
            "StackId": "arn:aws:cloudformation:us-east-1:000000000000:stack/root-service-local/380b2980-3d1f-49a7-8a8e-f455574dd463",
            "Parameters": [],
            "Tags": [
                {
                    "Value": "local",
                    "Key": "STAGE"
                }
            ],
            "Outputs": [
                {
                    "OutputKey": "ServerlessDeploymentBucketName",
                    "OutputValue": "root-service-local-ServerlessDeploymentBucket-V42VYOBG30M1"
                },
                {
                    "ExportName": "local-SharedGateway-restApiId",
                    "OutputKey": "apiGatewayRestApiId",
                    "OutputValue": "6lmwod0qxv"
                },
                {
                    "ExportName": "local-SharedGateway-rootResourceId",
                    "OutputKey": "apiGatewayRestApiRootResourceId",
                    "OutputValue": "1cgu6jfibl"
                }
            ],
            "CreationTime": "2010-07-27T22:28:28Z",
            "StackName": "root-service-local",
            "NotificationARNs": [],
            "StackStatus": "UPDATE_COMPLETE",
            "DisableRollback": false
        }
    ]
}
```

We are then importing the values into another service:

```yaml
provider:
  name: aws
  runtime: nodejs12.x
  region: ${opt:region, 'us-east-1'}
  apiGateway: 
    restApiId:
      'Fn::ImportValue': ${self:custom.stage}-SharedGateway-restApiId
    restApiRootResourceId:
      'Fn::ImportValue': ${self:custom.stage}-SharedGateway-rootResourceId
```

The issue arises when we attempt to deploy this service locally:

`ServerlessError: No export named local-SharedGateway-rootResourceId found.`

Sure enough, the shared gateway is not listed in the cloudformation exports:

```json
❯ awslocal cloudformation list-exports                                                                                                                                                    
{
    "Exports": []
}
```

Is this supported by Localstack?  Has anyone successfully shared resources between Lambda functions?  I feel that I am missing something simple...
stack_name = self._get_param('StackName')
        backend = self.cloudformation_backend
        stack = backend.get_stack(stack_name)
        if not stack:
            
            stack = ([stk for id, stk in backend.deleted_stacks.items() if stk.name == stack_name] or [0])[0]
        if not stack:
            raise ValidationError(stack_name,
                message='Unable to find stack "%s" in region %s' % (stack_name, aws_stack.get_region()))
        template = self.response_template(responses.DESCRIBE_STACK_EVENTS_RESPONSE)
        return template.render(stack=stack)
    responses.CloudFormationResponse.describe_stack_events = cf_describe_stack_events
    
    for region in boto3.session.Session().get_available_regions('lambda'):
        if region not in lambda_models.lambda_backends:
            lambda_models.lambda_backends[region] = lambda_models.LambdaBackend(region)
    
    def initialize_resources(self):
        def set_status(status):
            self._add_stack_event(status)
            self.status = status
        self.resource_map.create()
        self.output_map.create()
        def run_loop(*args):