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...
props = cloudformation_json['Properties']
        name = props['StageName']
        deployment_id = props.get('Id') or short_uid()
        description = props.get('Description') or ''
        return apigw_models.Deployment(deployment_id, name, description)
    @classmethod
    def Resource_create_from_cloudformation_json(cls, resource_name, cloudformation_json, region_name):
        props = cloudformation_json['Properties']
        region_name = props.get('Region') or aws_stack.get_region()
        path_part = props.get('PathPart')
        api_id = props.get('RestApiId')
        parent_id = props.get('ParentId')
        id = props.get('Id') or short_uid()
        return apigw_models.Resource(id, region_name, api_id, path_part, parent_id)
    @classmethod
    def Method_create_from_cloudformation_json(cls, resource_name, cloudformation_json, region_name):
        props = cloudformation_json['Properties']
        method_type = props.get('HttpMethod')
        authorization_type = props.get('AuthorizationType')
        return apigw_models.Method(method_type, authorization_type)
    apigw_models.RestAPI.create_from_cloudformation_json = RestAPI_create_from_cloudformation_json
    apigw_models.RestAPI.get_cfn_attribute = RestAPI_get_cfn_attribute
    apigw_models.Deployment.create_from_cloudformation_json = Deployment_create_from_cloudformation_json
    apigw_models.Resource.create_from_cloudformation_json = Resource_create_from_cloudformation_json
    apigw_models.Method.create_from_cloudformation_json = Method_create_from_cloudformation_json
    
    
    def describe_stack_resource(self):