eoapi-cdk 8.2.2__tar.gz → 8.3.0__tar.gz

{eoapi_cdk-8.2.2/src/eoapi_cdk.egg-info → eoapi_cdk-8.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eoapi-cdk
-Version: 8.2.2
+Version: 8.3.0
 Summary: A set of constructs deploying pgSTAC with CDK
 Home-page: https://github.com/developmentseed/eoapi-cdk.git
 Author: Anthony Lukach<anthony@developmentseed.org>

{eoapi_cdk-8.2.2 → eoapi_cdk-8.3.0}/setup.py

@@ -5,7 +5,7 @@ kwargs = json.loads(
     """
 {
     "name": "eoapi-cdk",
-    "version": "8.2.2",
+    "version": "8.3.0",
     "description": "A set of constructs deploying pgSTAC with CDK",
     "license": "ISC",
     "url": "https://github.com/developmentseed/eoapi-cdk.git",
@@ -26,7 +26,7 @@ kwargs = json.loads(
     ],
     "package_data": {
         "eoapi_cdk._jsii": [
-            "eoapi-cdk@8.2.2.jsii.tgz"
+            "eoapi-cdk@8.3.0.jsii.tgz"
         ],
         "eoapi_cdk": [
             "py.typed"

{eoapi_cdk-8.2.2 → eoapi_cdk-8.3.0}/src/eoapi_cdk/__init__.py

@@ -2828,27 +2828,27 @@ class StacIngestorProps:
         )
 
 
-class StacItemLoader(
+class StacLoader(
     _constructs_77d1e7e8.Construct,
     metaclass=jsii.JSIIMeta,
-    jsii_type="eoapi-cdk.StacItemLoader",
+    jsii_type="eoapi-cdk.StacLoader",
 ):
-    '''(experimental) AWS CDK Construct for STAC Item Loading Infrastructure.
+    '''(experimental) AWS CDK Construct for STAC Object Loading Infrastructure.
 
-    The StacItemLoader creates a serverless, event-driven system for loading
-    STAC (SpatioTemporal Asset Catalog) items into a PostgreSQL database with
+    The StacLoader creates a serverless, event-driven system for loading
+    STAC (SpatioTemporal Asset Catalog) objects into a PostgreSQL database with
     the pgstac extension. This construct supports multiple ingestion pathways
-    for flexible STAC item loading.
+    for flexible STAC object loading.
 
 
     Architecture Overview
 
     This construct creates the following AWS resources:
 
-    - **SNS Topic**: Entry point for STAC items and S3 event notifications
+    - **SNS Topic**: Entry point for STAC objects and S3 event notifications
     - **SQS Queue**: Buffers and batches messages before processing (60-second visibility timeout)
     - **Dead Letter Queue**: Captures failed loading attempts after 5 retries
-    - **Lambda Function**: Python function that processes batches and inserts items into pgstac
+    - **Lambda Function**: Python function that processes batches and inserts objects into pgstac
 
 
 
@@ -2857,20 +2857,20 @@ class StacItemLoader(
     The loader supports two primary data ingestion patterns:
 
 
-    Direct STAC Item Publishing
+    Direct STAC Object Publishing
 
-    1. STAC items (JSON) are published directly to the SNS topic in message bodies
-    2. The SQS queue collects messages and batches them (up to {batchSize} items or 1 minute window)
-    3. The Lambda function receives batches, validates items, and inserts into pgstac
+    1. STAC objects (JSON) are published directly to the SNS topic in message bodies
+    2. The SQS queue collects messages and batches them (up to {batchSize} objects or 1 minute window)
+    3. The Lambda function receives batches, validates objects, and inserts into pgstac
 
 
 
     S3 Event-Driven Loading
 
     1. An S3 bucket is configured to send notifications to the SNS topic when json files are created
-    2. STAC items are uploaded to S3 buckets as JSON/GeoJSON files
-    3. S3 event notifications are sent to the SNS topic when items are uploaded
-    4. The Lambda function receives S3 events in the SQS message batch, fetches items from S3, and loads into pgstac
+    2. STAC objects are uploaded to S3 buckets as JSON/GeoJSON files
+    3. S3 event notifications are sent to the SNS topic when objects are uploaded
+    4. The Lambda function receives S3 events in the SQS message batch, fetches objects from S3, and loads into pgstac
 
 
 
@@ -2883,7 +2883,7 @@ class StacItemLoader(
       triggers after ``maxBatchingWindow`` minutes (default: 1 minute)
     - **Trigger Condition**: Lambda executes when EITHER condition is met first
     - **Concurrency**: Limited to ``maxConcurrency`` concurrent executions to prevent database overload
-    - **Partial Failures**: Uses ``reportBatchItemFailures`` to retry only failed items
+    - **Partial Failures**: Uses ``reportBatchItemFailures`` to retry only failed objects
 
     This approach balances throughput (larger batches = fewer database connections)
     with latency (time-based triggers prevent indefinite waiting).
@@ -2893,14 +2893,14 @@ class StacItemLoader(
 
     Failed messages are sent to the dead letter queue after 5 processing attempts.
     **Important**: This construct provides NO automated handling of dead letter queue
-    messages - monitoring, inspection, and reprocessing of failed items is the
+    messages - monitoring, inspection, and reprocessing of failed objects is the
     responsibility of the implementing application.
 
     Consider implementing:
 
     - CloudWatch alarms on dead letter queue depth
     - Manual or automated reprocessing workflows
-    - Logging and alerting for failed items
+    - Logging and alerting for failed objects
     - Regular cleanup of old dead letter messages (14-day retention)
 
 
@@ -2919,7 +2919,7 @@ class StacItemLoader(
 
     Before using this construct, ensure:
 
-    - The pgstac database has collections loaded (items require existing collection IDs)
+    - The pgstac database has collections loaded (objects require existing collection IDs)
     - Database credentials are stored in AWS Secrets Manager
     - The pgstac extension is properly installed and configured
 
@@ -2934,25 +2934,38 @@ class StacItemLoader(
          pgstacVersion: '0.9.5'
        });
 
-       // Create item loader
-       const loader = new StacItemLoader(this, 'ItemLoader', {
+       // Create Object loader
+       const loader = new StacLoader(this, 'StacLoader', {
          pgstacDb: database,
-         batchSize: 1000,          // Process up to 1000 items per batch
+         batchSize: 1000,          // Process up to 1000 objects per batch
          maxBatchingWindowMinutes: 1, // Wait max 1 minute to fill batch
          lambdaTimeoutSeconds: 300     // Allow up to 300 seconds for database operations
        });
 
-       // The topic ARN can be used by other services to publish items
+       // The topic ARN can be used by other services to publish objects
        new CfnOutput(this, 'LoaderTopicArn', {
          value: loader.topic.topicArn
        });
 
 
-    Direct Item Publishing
+    Direct Object Publishing
+
+    External services can publish STAC objects directly to the topic::
 
-    External services can publish STAC items directly to the topic::
+       aws sns publish --topic-arn $STAC_LOAD_TOPIC --message  '{
+         "id": "example-collection",
+         "type": "Collection",
+         "title": "Example Collection",
+         "description": "An example collection",
+         "license": "proprietary",
+         "extent": {
+             "spatial": {"bbox": [[-180, -90, 180, 90]]},
+             "temporal": {"interval": [[null, null]]},
+         },
+         "stac_version": "1.1.0",
+       }'
 
-       aws sns publish --topic-arn $ITEM_LOAD_TOPIC --message '{
+       aws sns publish --topic-arn $STAC_LOAD_TOPIC --message '{
          "type": "Feature",
          "stac_version": "1.0.0",
          "id": "example-item",
@@ -2965,7 +2978,7 @@ class StacItemLoader(
     S3 Event Configuration
 
     To enable S3 event-driven loading, configure S3 bucket notifications to send
-    events to the SNS topic when STAC items (.json or .geojson files) are uploaded::
+    events to the SNS topic when STAC objects (.json or .geojson files) are uploaded::
 
        // Configure S3 bucket to send notifications to the loader topic
        bucket.addEventNotification(
@@ -2980,19 +2993,19 @@ class StacItemLoader(
          { suffix: '.geojson' }
        );
 
-    When STAC items are uploaded to the configured S3 bucket, the loader will:
+    When STAC objects are uploaded to the configured S3 bucket, the loader will:
 
     1. Receive S3 event notifications via SNS
-    2. Fetch the STAC item JSON from S3
-    3. Validate and load the item into the pgstac database
+    2. Fetch the STAC JSON from S3
+    3. Validate and load the objects into the pgstac database
 
 
 
     Monitoring and Troubleshooting
 
     - Monitor Lambda logs: ``/aws/lambda/{FunctionName}``
-    - **Dead Letter Queue**: Check for failed items - **no automated handling provided**
-    - Use batch item failure reporting for partial batch processing
+    - **Dead Letter Queue**: Check for failed objects - **no automated handling provided**
+    - Use batch objects failure reporting for partial batch processing
     - CloudWatch metrics available for queue depth and Lambda performance
 
 
@@ -3036,25 +3049,25 @@ class StacItemLoader(
         '''
         :param scope: -
         :param id: -
-        :param pgstac_db: (experimental) The PgSTAC database instance to load items into. This database must have the pgstac extension installed and be properly configured with collections before items can be loaded. The loader will use AWS Secrets Manager to securely access database credentials.
-        :param batch_size: (experimental) SQS batch size for lambda event source. This determines the maximum number of STAC items that will be processed together in a single lambda invocation. Larger batch sizes improve database insertion efficiency but require more memory and longer processing time. **Batching Behavior**: SQS will wait to accumulate up to this many messages before triggering the Lambda, OR until the maxBatchingWindow timeout is reached, whichever comes first. This creates an efficient balance between throughput and latency. Default: 500
+        :param pgstac_db: (experimental) The PgSTAC database instance to load data into. This database must have the pgstac extension installed and be properly configured with collections before objects can be loaded. The loader will use AWS Secrets Manager to securely access database credentials.
+        :param batch_size: (experimental) SQS batch size for lambda event source. This determines the maximum number of STAC objects that will be processed together in a single lambda invocation. Larger batch sizes improve database insertion efficiency but require more memory and longer processing time. **Batching Behavior**: SQS will wait to accumulate up to this many messages before triggering the Lambda, OR until the maxBatchingWindow timeout is reached, whichever comes first. This creates an efficient balance between throughput and latency. Default: 500
         :param environment: (experimental) Additional environment variables for the lambda function. These will be merged with the default environment variables including PGSTAC_SECRET_ARN. Use this for custom configuration or debugging flags. If you want to enable the option to upload a boilerplate collection record in the event that the collection record does not yet exist for an item that is set to be loaded, set the variable ``"CREATE_COLLECTIONS_IF_MISSING": "TRUE"``.
         :param lambda_function_options: (experimental) Can be used to override the default lambda function properties. Default: - defined in the construct.
         :param lambda_runtime: (experimental) The lambda runtime to use for the item loading function. The function is implemented in Python and uses pypgstac for database operations. Ensure the runtime version is compatible with the pgstac version specified in the database configuration. Default: lambda.Runtime.PYTHON_3_11
-        :param lambda_timeout_seconds: (experimental) The timeout for the item load lambda in seconds. This should accommodate the time needed to process up to ``batchSize`` items and perform database insertions. The SQS visibility timeout will be set to this value plus 10 seconds. Default: 300
-        :param max_batching_window_minutes: (experimental) Maximum batching window in minutes. Even if the batch size isn't reached, the lambda will be triggered after this time period to ensure timely processing of items. This prevents items from waiting indefinitely in low-volume scenarios. **Important**: This timeout works in conjunction with batchSize - SQS will trigger the Lambda when EITHER the batch size is reached OR this time window expires, ensuring items are processed in a timely manner regardless of volume. Default: 1
-        :param max_concurrency: (experimental) Maximum concurrent executions for the StacItemLoader Lambda function. This limit will be applied to the Lambda function and will control how many concurrent batches will be released from the SQS queue. Default: 2
-        :param memory_size: (experimental) Memory size for the lambda function in MB. Higher memory allocation may improve performance when processing large batches of STAC items, especially for memory-intensive database operations. Default: 1024
+        :param lambda_timeout_seconds: (experimental) The timeout for the item load lambda in seconds. This should accommodate the time needed to process up to ``batchSize`` objects and perform database insertions. The SQS visibility timeout will be set to this value plus 10 seconds. Default: 300
+        :param max_batching_window_minutes: (experimental) Maximum batching window in minutes. Even if the batch size isn't reached, the lambda will be triggered after this time period to ensure timely processing of objects. This prevents objects from waiting indefinitely in low-volume scenarios. **Important**: This timeout works in conjunction with batchSize - SQS will trigger the Lambda when EITHER the batch size is reached OR this time window expires, ensuring objects are processed in a timely manner regardless of volume. Default: 1
+        :param max_concurrency: (experimental) Maximum concurrent executions for the StacLoader Lambda function. This limit will be applied to the Lambda function and will control how many concurrent batches will be released from the SQS queue. Default: 2
+        :param memory_size: (experimental) Memory size for the lambda function in MB. Higher memory allocation may improve performance when processing large batches of STAC objects, especially for memory-intensive database operations. Default: 1024
         :param subnet_selection: (experimental) Subnet into which the lambda should be deployed.
         :param vpc: (experimental) VPC into which the lambda should be deployed.
 
         :stability: experimental
         '''
         if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__3993e1684b5582edef005457882c4cfe3c53062e1f47dc584d35a9cfa71c31e0)
+            type_hints = typing.get_type_hints(_typecheckingstub__07e7381e15a2bb6d7b4a36ff70efaaf4a44e5bcce99a053eb5c48cb9dfca728d)
             check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
-        props = StacItemLoaderProps(
+        props = StacLoaderProps(
             pgstac_db=pgstac_db,
             batch_size=batch_size,
             environment=environment,
@@ -3073,7 +3086,7 @@ class StacItemLoader(
     @builtins.property
     @jsii.member(jsii_name="deadLetterQueue")
     def dead_letter_queue(self) -> _aws_cdk_aws_sqs_ceddda9d.Queue:
-        '''(experimental) Dead letter queue for failed item loading attempts.
+        '''(experimental) Dead letter queue for failed objects loading attempts.
 
         Messages that fail processing after 5 attempts are sent here
         for inspection and potential replay. Retains messages for 14 days
@@ -3095,13 +3108,13 @@ class StacItemLoader(
     @builtins.property
     @jsii.member(jsii_name="lambdaFunction")
     def lambda_function(self) -> _aws_cdk_aws_lambda_ceddda9d.Function:
-        '''(experimental) The Lambda function that loads STAC items into the pgstac database.
+        '''(experimental) The Lambda function that loads STAC objects into the pgstac database.
 
         This Python function receives batches of messages from SQS and processes
         them based on their type:
 
-        - Direct STAC items: Validates and loads directly into pgstac
-        - S3 events: Fetches STAC items from S3, validates, and loads into pgstac
+        - Direct STAC objects: Validates and loads directly into pgstac
+        - S3 events: Fetches STAC JSON from S3, validates, and loads into pgstac
 
         The function connects to PostgreSQL using credentials from Secrets Manager
         and uses pypgstac for efficient database operations.
@@ -3115,7 +3128,7 @@ class StacItemLoader(
     def queue(self) -> _aws_cdk_aws_sqs_ceddda9d.Queue:
         '''(experimental) The SQS queue that buffers messages before processing.
 
-        This queue collects both direct STAC items from SNS and S3 event
+        This queue collects both direct STAC objects from SNS and S3 event
         notifications, batching them for efficient database operations.
         Configured with a visibility timeout that accommodates Lambda
         processing time plus buffer.
@@ -3127,12 +3140,12 @@ class StacItemLoader(
     @builtins.property
     @jsii.member(jsii_name="topic")
     def topic(self) -> _aws_cdk_aws_sns_ceddda9d.Topic:
-        '''(experimental) The SNS topic that receives STAC items and S3 event notifications for loading.
+        '''(experimental) The SNS topic that receives STAC objects and S3 event notifications for loading.
 
         This topic serves as the entry point for two types of events:
 
-        1. Direct STAC item JSON documents published by external services
-        2. S3 event notifications when STAC items are uploaded to configured buckets
+        1. Direct STAC JSON documents published by external services
+        2. S3 event notifications when STAC objects are uploaded to configured buckets
 
         The topic fans out to the SQS queue for batched processing.
 
@@ -3142,7 +3155,7 @@ class StacItemLoader(
 
 
 @jsii.data_type(
-    jsii_type="eoapi-cdk.StacItemLoaderProps",
+    jsii_type="eoapi-cdk.StacLoaderProps",
     jsii_struct_bases=[],
     name_mapping={
         "pgstac_db": "pgstacDb",
@@ -3158,7 +3171,7 @@ class StacItemLoader(
         "vpc": "vpc",
     },
 )
-class StacItemLoaderProps:
+class StacLoaderProps:
     def __init__(
         self,
         *,
@@ -3174,26 +3187,26 @@ class StacItemLoaderProps:
         subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
         vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
     ) -> None:
-        '''(experimental) Configuration properties for the StacItemLoader construct.
+        '''(experimental) Configuration properties for the StacLoader construct.
 
-        The StacItemLoader is part of a two-phase serverless STAC ingestion pipeline
-        that loads STAC items into a pgstac database. This construct creates
-        the infrastructure for receiving STAC items from multiple sources:
+        The StacLoader is part of a two-phase serverless STAC ingestion pipeline
+        that loads STAC collections and items into a pgstac database. This construct creates
+        the infrastructure for receiving STAC objects from multiple sources:
 
         1. SNS messages containing STAC metadata (direct ingestion)
-        2. S3 event notifications for STAC items uploaded to S3 buckets
+        2. S3 event notifications for STAC objects uploaded to S3 buckets
 
-        Items from both sources are batched and inserted into PostgreSQL with the pgstac extension.
+        Objects from both sources are batched and inserted into PostgreSQL with the pgstac extension.
 
-        :param pgstac_db: (experimental) The PgSTAC database instance to load items into. This database must have the pgstac extension installed and be properly configured with collections before items can be loaded. The loader will use AWS Secrets Manager to securely access database credentials.
-        :param batch_size: (experimental) SQS batch size for lambda event source. This determines the maximum number of STAC items that will be processed together in a single lambda invocation. Larger batch sizes improve database insertion efficiency but require more memory and longer processing time. **Batching Behavior**: SQS will wait to accumulate up to this many messages before triggering the Lambda, OR until the maxBatchingWindow timeout is reached, whichever comes first. This creates an efficient balance between throughput and latency. Default: 500
+        :param pgstac_db: (experimental) The PgSTAC database instance to load data into. This database must have the pgstac extension installed and be properly configured with collections before objects can be loaded. The loader will use AWS Secrets Manager to securely access database credentials.
+        :param batch_size: (experimental) SQS batch size for lambda event source. This determines the maximum number of STAC objects that will be processed together in a single lambda invocation. Larger batch sizes improve database insertion efficiency but require more memory and longer processing time. **Batching Behavior**: SQS will wait to accumulate up to this many messages before triggering the Lambda, OR until the maxBatchingWindow timeout is reached, whichever comes first. This creates an efficient balance between throughput and latency. Default: 500
         :param environment: (experimental) Additional environment variables for the lambda function. These will be merged with the default environment variables including PGSTAC_SECRET_ARN. Use this for custom configuration or debugging flags. If you want to enable the option to upload a boilerplate collection record in the event that the collection record does not yet exist for an item that is set to be loaded, set the variable ``"CREATE_COLLECTIONS_IF_MISSING": "TRUE"``.
         :param lambda_function_options: (experimental) Can be used to override the default lambda function properties. Default: - defined in the construct.
         :param lambda_runtime: (experimental) The lambda runtime to use for the item loading function. The function is implemented in Python and uses pypgstac for database operations. Ensure the runtime version is compatible with the pgstac version specified in the database configuration. Default: lambda.Runtime.PYTHON_3_11
-        :param lambda_timeout_seconds: (experimental) The timeout for the item load lambda in seconds. This should accommodate the time needed to process up to ``batchSize`` items and perform database insertions. The SQS visibility timeout will be set to this value plus 10 seconds. Default: 300
-        :param max_batching_window_minutes: (experimental) Maximum batching window in minutes. Even if the batch size isn't reached, the lambda will be triggered after this time period to ensure timely processing of items. This prevents items from waiting indefinitely in low-volume scenarios. **Important**: This timeout works in conjunction with batchSize - SQS will trigger the Lambda when EITHER the batch size is reached OR this time window expires, ensuring items are processed in a timely manner regardless of volume. Default: 1
-        :param max_concurrency: (experimental) Maximum concurrent executions for the StacItemLoader Lambda function. This limit will be applied to the Lambda function and will control how many concurrent batches will be released from the SQS queue. Default: 2
-        :param memory_size: (experimental) Memory size for the lambda function in MB. Higher memory allocation may improve performance when processing large batches of STAC items, especially for memory-intensive database operations. Default: 1024
+        :param lambda_timeout_seconds: (experimental) The timeout for the item load lambda in seconds. This should accommodate the time needed to process up to ``batchSize`` objects and perform database insertions. The SQS visibility timeout will be set to this value plus 10 seconds. Default: 300
+        :param max_batching_window_minutes: (experimental) Maximum batching window in minutes. Even if the batch size isn't reached, the lambda will be triggered after this time period to ensure timely processing of objects. This prevents objects from waiting indefinitely in low-volume scenarios. **Important**: This timeout works in conjunction with batchSize - SQS will trigger the Lambda when EITHER the batch size is reached OR this time window expires, ensuring objects are processed in a timely manner regardless of volume. Default: 1
+        :param max_concurrency: (experimental) Maximum concurrent executions for the StacLoader Lambda function. This limit will be applied to the Lambda function and will control how many concurrent batches will be released from the SQS queue. Default: 2
+        :param memory_size: (experimental) Memory size for the lambda function in MB. Higher memory allocation may improve performance when processing large batches of STAC objects, especially for memory-intensive database operations. Default: 1024
         :param subnet_selection: (experimental) Subnet into which the lambda should be deployed.
         :param vpc: (experimental) VPC into which the lambda should be deployed.
 
@@ -3201,7 +3214,7 @@ class StacItemLoaderProps:
 
         Example::
 
-            const loader = new StacItemLoader(this, 'ItemLoader', {
+            const loader = new StacLoader(this, 'StacLoader', {
               pgstacDb: database,
               batchSize: 1000,
               maxBatchingWindowMinutes: 1,
@@ -3211,7 +3224,7 @@ class StacItemLoaderProps:
         if isinstance(subnet_selection, dict):
             subnet_selection = _aws_cdk_aws_ec2_ceddda9d.SubnetSelection(**subnet_selection)
         if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__4bbe16b8ca579680ab8c75903813675de5c4f4e8877137194262298af5f8093d)
+            type_hints = typing.get_type_hints(_typecheckingstub__f4ba6b725ddd9c1870cc4cb313a955d81ffb068eda41ee786161dacf35a03192)
             check_type(argname="argument pgstac_db", value=pgstac_db, expected_type=type_hints["pgstac_db"])
             check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
             check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
@@ -3249,10 +3262,10 @@ class StacItemLoaderProps:
 
     @builtins.property
     def pgstac_db(self) -> PgStacDatabase:
-        '''(experimental) The PgSTAC database instance to load items into.
+        '''(experimental) The PgSTAC database instance to load data into.
 
         This database must have the pgstac extension installed and be properly
-        configured with collections before items can be loaded. The loader will
+        configured with collections before objects can be loaded. The loader will
         use AWS Secrets Manager to securely access database credentials.
 
         :stability: experimental
@@ -3265,7 +3278,7 @@ class StacItemLoaderProps:
     def batch_size(self) -> typing.Optional[jsii.Number]:
         '''(experimental) SQS batch size for lambda event source.
 
-        This determines the maximum number of STAC items that will be
+        This determines the maximum number of STAC objects that will be
         processed together in a single lambda invocation. Larger batch
         sizes improve database insertion efficiency but require more
         memory and longer processing time.
@@ -3331,7 +3344,7 @@ class StacItemLoaderProps:
         '''(experimental) The timeout for the item load lambda in seconds.
 
         This should accommodate the time needed to process up to ``batchSize``
-        items and perform database insertions. The SQS visibility timeout
+        objects and perform database insertions. The SQS visibility timeout
         will be set to this value plus 10 seconds.
 
         :default: 300
@@ -3346,12 +3359,12 @@ class StacItemLoaderProps:
         '''(experimental) Maximum batching window in minutes.
 
         Even if the batch size isn't reached, the lambda will be triggered
-        after this time period to ensure timely processing of items.
-        This prevents items from waiting indefinitely in low-volume scenarios.
+        after this time period to ensure timely processing of objects.
+        This prevents objects from waiting indefinitely in low-volume scenarios.
 
         **Important**: This timeout works in conjunction with batchSize - SQS
         will trigger the Lambda when EITHER the batch size is reached OR this
-        time window expires, ensuring items are processed in a timely manner
+        time window expires, ensuring objects are processed in a timely manner
         regardless of volume.
 
         :default: 1
@@ -3363,7 +3376,7 @@ class StacItemLoaderProps:
 
     @builtins.property
     def max_concurrency(self) -> typing.Optional[jsii.Number]:
-        '''(experimental) Maximum concurrent executions for the StacItemLoader Lambda function.
+        '''(experimental) Maximum concurrent executions for the StacLoader Lambda function.
 
         This limit will be applied to the Lambda function and will control how
         many concurrent batches will be released from the SQS queue.
@@ -3380,7 +3393,7 @@ class StacItemLoaderProps:
         '''(experimental) Memory size for the lambda function in MB.
 
         Higher memory allocation may improve performance when processing
-        large batches of STAC items, especially for memory-intensive
+        large batches of STAC objects, especially for memory-intensive
         database operations.
 
         :default: 1024
@@ -3417,7 +3430,7 @@ class StacItemLoaderProps:
         return not (rhs == self)
 
     def __repr__(self) -> str:
-        return "StacItemLoaderProps(%s)" % ", ".join(
+        return "StacLoaderProps(%s)" % ", ".join(
             k + "=" + repr(v) for k, v in self._values.items()
         )
 
@@ -3489,7 +3502,7 @@ class StactoolsItemGenerator(
     Example::
 
        // Create item loader first (or get existing topic ARN)
-       const loader = new StacItemLoader(this, 'ItemLoader', {
+       const loader = new StacLoader(this, 'ItemLoader', {
          pgstacDb: database
        });
 
@@ -3574,7 +3587,7 @@ class StactoolsItemGenerator(
         '''
         :param scope: -
         :param id: -
-        :param item_load_topic_arn: (experimental) ARN of the SNS topic to publish generated items to. This is typically the topic from a StacItemLoader construct. Generated STAC items will be published here for downstream processing and database insertion.
+        :param item_load_topic_arn: (experimental) ARN of the SNS topic to publish generated items to. This is typically the topic from a StacLoader construct. Generated STAC items will be published here for downstream processing and database insertion.
         :param batch_size: (experimental) SQS batch size for lambda event source. This determines how many generation requests are processed together in a single lambda invocation. Unlike the loader, generation typically processes items individually, so smaller batch sizes are common. Default: 10
         :param environment: (experimental) Additional environment variables for the lambda function. These will be merged with default environment variables including ITEM_LOAD_TOPIC_ARN and LOG_LEVEL. Use this for custom configuration or to pass credentials for external data sources.
         :param lambda_function_options: (experimental) Can be used to override the default lambda function properties. Default: - defined in the construct.
@@ -3696,7 +3709,7 @@ class StactoolsItemGeneratorProps:
         infrastructure for the first phase of the pipeline - processing metadata
         about assets and transforming them into standardized STAC items.
 
-        :param item_load_topic_arn: (experimental) ARN of the SNS topic to publish generated items to. This is typically the topic from a StacItemLoader construct. Generated STAC items will be published here for downstream processing and database insertion.
+        :param item_load_topic_arn: (experimental) ARN of the SNS topic to publish generated items to. This is typically the topic from a StacLoader construct. Generated STAC items will be published here for downstream processing and database insertion.
         :param batch_size: (experimental) SQS batch size for lambda event source. This determines how many generation requests are processed together in a single lambda invocation. Unlike the loader, generation typically processes items individually, so smaller batch sizes are common. Default: 10
         :param environment: (experimental) Additional environment variables for the lambda function. These will be merged with default environment variables including ITEM_LOAD_TOPIC_ARN and LOG_LEVEL. Use this for custom configuration or to pass credentials for external data sources.
         :param lambda_function_options: (experimental) Can be used to override the default lambda function properties. Default: - defined in the construct.
@@ -3758,7 +3771,7 @@ class StactoolsItemGeneratorProps:
     def item_load_topic_arn(self) -> builtins.str:
         '''(experimental) ARN of the SNS topic to publish generated items to.
 
-        This is typically the topic from a StacItemLoader construct.
+        This is typically the topic from a StacLoader construct.
         Generated STAC items will be published here for downstream
         processing and database insertion.
 
@@ -4385,6 +4398,336 @@ class TitilerPgstacApiLambda(
         jsii.set(self, "titilerPgstacLambdaFunction", value) # pyright: ignore[reportArgumentType]
 
 
+class StacItemLoader(
+    StacLoader,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="eoapi-cdk.StacItemLoader",
+):
+    '''
+    :deprecated: Use StacLoader instead. StacItemLoader will be removed in a future version.
+
+    :stability: deprecated
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        pgstac_db: PgStacDatabase,
+        batch_size: typing.Optional[jsii.Number] = None,
+        environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        lambda_function_options: typing.Any = None,
+        lambda_runtime: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime] = None,
+        lambda_timeout_seconds: typing.Optional[jsii.Number] = None,
+        max_batching_window_minutes: typing.Optional[jsii.Number] = None,
+        max_concurrency: typing.Optional[jsii.Number] = None,
+        memory_size: typing.Optional[jsii.Number] = None,
+        subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
+        vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: -
+        :param pgstac_db: (experimental) The PgSTAC database instance to load data into. This database must have the pgstac extension installed and be properly configured with collections before objects can be loaded. The loader will use AWS Secrets Manager to securely access database credentials.
+        :param batch_size: (experimental) SQS batch size for lambda event source. This determines the maximum number of STAC objects that will be processed together in a single lambda invocation. Larger batch sizes improve database insertion efficiency but require more memory and longer processing time. **Batching Behavior**: SQS will wait to accumulate up to this many messages before triggering the Lambda, OR until the maxBatchingWindow timeout is reached, whichever comes first. This creates an efficient balance between throughput and latency. Default: 500
+        :param environment: (experimental) Additional environment variables for the lambda function. These will be merged with the default environment variables including PGSTAC_SECRET_ARN. Use this for custom configuration or debugging flags. If you want to enable the option to upload a boilerplate collection record in the event that the collection record does not yet exist for an item that is set to be loaded, set the variable ``"CREATE_COLLECTIONS_IF_MISSING": "TRUE"``.
+        :param lambda_function_options: (experimental) Can be used to override the default lambda function properties. Default: - defined in the construct.
+        :param lambda_runtime: (experimental) The lambda runtime to use for the item loading function. The function is implemented in Python and uses pypgstac for database operations. Ensure the runtime version is compatible with the pgstac version specified in the database configuration. Default: lambda.Runtime.PYTHON_3_11
+        :param lambda_timeout_seconds: (experimental) The timeout for the item load lambda in seconds. This should accommodate the time needed to process up to ``batchSize`` objects and perform database insertions. The SQS visibility timeout will be set to this value plus 10 seconds. Default: 300
+        :param max_batching_window_minutes: (experimental) Maximum batching window in minutes. Even if the batch size isn't reached, the lambda will be triggered after this time period to ensure timely processing of objects. This prevents objects from waiting indefinitely in low-volume scenarios. **Important**: This timeout works in conjunction with batchSize - SQS will trigger the Lambda when EITHER the batch size is reached OR this time window expires, ensuring objects are processed in a timely manner regardless of volume. Default: 1
+        :param max_concurrency: (experimental) Maximum concurrent executions for the StacLoader Lambda function. This limit will be applied to the Lambda function and will control how many concurrent batches will be released from the SQS queue. Default: 2
+        :param memory_size: (experimental) Memory size for the lambda function in MB. Higher memory allocation may improve performance when processing large batches of STAC objects, especially for memory-intensive database operations. Default: 1024
+        :param subnet_selection: (experimental) Subnet into which the lambda should be deployed.
+        :param vpc: (experimental) VPC into which the lambda should be deployed.
+
+        :stability: deprecated
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__3993e1684b5582edef005457882c4cfe3c53062e1f47dc584d35a9cfa71c31e0)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = StacLoaderProps(
+            pgstac_db=pgstac_db,
+            batch_size=batch_size,
+            environment=environment,
+            lambda_function_options=lambda_function_options,
+            lambda_runtime=lambda_runtime,
+            lambda_timeout_seconds=lambda_timeout_seconds,
+            max_batching_window_minutes=max_batching_window_minutes,
+            max_concurrency=max_concurrency,
+            memory_size=memory_size,
+            subnet_selection=subnet_selection,
+            vpc=vpc,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+
+@jsii.data_type(
+    jsii_type="eoapi-cdk.StacItemLoaderProps",
+    jsii_struct_bases=[StacLoaderProps],
+    name_mapping={
+        "pgstac_db": "pgstacDb",
+        "batch_size": "batchSize",
+        "environment": "environment",
+        "lambda_function_options": "lambdaFunctionOptions",
+        "lambda_runtime": "lambdaRuntime",
+        "lambda_timeout_seconds": "lambdaTimeoutSeconds",
+        "max_batching_window_minutes": "maxBatchingWindowMinutes",
+        "max_concurrency": "maxConcurrency",
+        "memory_size": "memorySize",
+        "subnet_selection": "subnetSelection",
+        "vpc": "vpc",
+    },
+)
+class StacItemLoaderProps(StacLoaderProps):
+    def __init__(
+        self,
+        *,
+        pgstac_db: PgStacDatabase,
+        batch_size: typing.Optional[jsii.Number] = None,
+        environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        lambda_function_options: typing.Any = None,
+        lambda_runtime: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime] = None,
+        lambda_timeout_seconds: typing.Optional[jsii.Number] = None,
+        max_batching_window_minutes: typing.Optional[jsii.Number] = None,
+        max_concurrency: typing.Optional[jsii.Number] = None,
+        memory_size: typing.Optional[jsii.Number] = None,
+        subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
+        vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
+    ) -> None:
+        '''
+        :param pgstac_db: (experimental) The PgSTAC database instance to load data into. This database must have the pgstac extension installed and be properly configured with collections before objects can be loaded. The loader will use AWS Secrets Manager to securely access database credentials.
+        :param batch_size: (experimental) SQS batch size for lambda event source. This determines the maximum number of STAC objects that will be processed together in a single lambda invocation. Larger batch sizes improve database insertion efficiency but require more memory and longer processing time. **Batching Behavior**: SQS will wait to accumulate up to this many messages before triggering the Lambda, OR until the maxBatchingWindow timeout is reached, whichever comes first. This creates an efficient balance between throughput and latency. Default: 500
+        :param environment: (experimental) Additional environment variables for the lambda function. These will be merged with the default environment variables including PGSTAC_SECRET_ARN. Use this for custom configuration or debugging flags. If you want to enable the option to upload a boilerplate collection record in the event that the collection record does not yet exist for an item that is set to be loaded, set the variable ``"CREATE_COLLECTIONS_IF_MISSING": "TRUE"``.
+        :param lambda_function_options: (experimental) Can be used to override the default lambda function properties. Default: - defined in the construct.
+        :param lambda_runtime: (experimental) The lambda runtime to use for the item loading function. The function is implemented in Python and uses pypgstac for database operations. Ensure the runtime version is compatible with the pgstac version specified in the database configuration. Default: lambda.Runtime.PYTHON_3_11
+        :param lambda_timeout_seconds: (experimental) The timeout for the item load lambda in seconds. This should accommodate the time needed to process up to ``batchSize`` objects and perform database insertions. The SQS visibility timeout will be set to this value plus 10 seconds. Default: 300
+        :param max_batching_window_minutes: (experimental) Maximum batching window in minutes. Even if the batch size isn't reached, the lambda will be triggered after this time period to ensure timely processing of objects. This prevents objects from waiting indefinitely in low-volume scenarios. **Important**: This timeout works in conjunction with batchSize - SQS will trigger the Lambda when EITHER the batch size is reached OR this time window expires, ensuring objects are processed in a timely manner regardless of volume. Default: 1
+        :param max_concurrency: (experimental) Maximum concurrent executions for the StacLoader Lambda function. This limit will be applied to the Lambda function and will control how many concurrent batches will be released from the SQS queue. Default: 2
+        :param memory_size: (experimental) Memory size for the lambda function in MB. Higher memory allocation may improve performance when processing large batches of STAC objects, especially for memory-intensive database operations. Default: 1024
+        :param subnet_selection: (experimental) Subnet into which the lambda should be deployed.
+        :param vpc: (experimental) VPC into which the lambda should be deployed.
+
+        :deprecated: Use StacLoaderProps instead. StacItemLoaderProps will be removed in a future version.
+
+        :stability: deprecated
+        '''
+        if isinstance(subnet_selection, dict):
+            subnet_selection = _aws_cdk_aws_ec2_ceddda9d.SubnetSelection(**subnet_selection)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__4bbe16b8ca579680ab8c75903813675de5c4f4e8877137194262298af5f8093d)
+            check_type(argname="argument pgstac_db", value=pgstac_db, expected_type=type_hints["pgstac_db"])
+            check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
+            check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
+            check_type(argname="argument lambda_function_options", value=lambda_function_options, expected_type=type_hints["lambda_function_options"])
+            check_type(argname="argument lambda_runtime", value=lambda_runtime, expected_type=type_hints["lambda_runtime"])
+            check_type(argname="argument lambda_timeout_seconds", value=lambda_timeout_seconds, expected_type=type_hints["lambda_timeout_seconds"])
+            check_type(argname="argument max_batching_window_minutes", value=max_batching_window_minutes, expected_type=type_hints["max_batching_window_minutes"])
+            check_type(argname="argument max_concurrency", value=max_concurrency, expected_type=type_hints["max_concurrency"])
+            check_type(argname="argument memory_size", value=memory_size, expected_type=type_hints["memory_size"])
+            check_type(argname="argument subnet_selection", value=subnet_selection, expected_type=type_hints["subnet_selection"])
+            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "pgstac_db": pgstac_db,
+        }
+        if batch_size is not None:
+            self._values["batch_size"] = batch_size
+        if environment is not None:
+            self._values["environment"] = environment
+        if lambda_function_options is not None:
+            self._values["lambda_function_options"] = lambda_function_options
+        if lambda_runtime is not None:
+            self._values["lambda_runtime"] = lambda_runtime
+        if lambda_timeout_seconds is not None:
+            self._values["lambda_timeout_seconds"] = lambda_timeout_seconds
+        if max_batching_window_minutes is not None:
+            self._values["max_batching_window_minutes"] = max_batching_window_minutes
+        if max_concurrency is not None:
+            self._values["max_concurrency"] = max_concurrency
+        if memory_size is not None:
+            self._values["memory_size"] = memory_size
+        if subnet_selection is not None:
+            self._values["subnet_selection"] = subnet_selection
+        if vpc is not None:
+            self._values["vpc"] = vpc
+
+    @builtins.property
+    def pgstac_db(self) -> PgStacDatabase:
+        '''(experimental) The PgSTAC database instance to load data into.
+
+        This database must have the pgstac extension installed and be properly
+        configured with collections before objects can be loaded. The loader will
+        use AWS Secrets Manager to securely access database credentials.
+
+        :stability: experimental
+        '''
+        result = self._values.get("pgstac_db")
+        assert result is not None, "Required property 'pgstac_db' is missing"
+        return typing.cast(PgStacDatabase, result)
+
+    @builtins.property
+    def batch_size(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) SQS batch size for lambda event source.
+
+        This determines the maximum number of STAC objects that will be
+        processed together in a single lambda invocation. Larger batch
+        sizes improve database insertion efficiency but require more
+        memory and longer processing time.
+
+        **Batching Behavior**: SQS will wait to accumulate up to this many
+        messages before triggering the Lambda, OR until the maxBatchingWindow
+        timeout is reached, whichever comes first. This creates an efficient
+        balance between throughput and latency.
+
+        :default: 500
+
+        :stability: experimental
+        '''
+        result = self._values.get("batch_size")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def environment(
+        self,
+    ) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
+        '''(experimental) Additional environment variables for the lambda function.
+
+        These will be merged with the default environment variables including
+        PGSTAC_SECRET_ARN. Use this for custom configuration or debugging flags.
+
+        If you want to enable the option to upload a boilerplate collection record
+        in the event that the collection record does not yet exist for an item that
+        is set to be loaded, set the variable ``"CREATE_COLLECTIONS_IF_MISSING": "TRUE"``.
+
+        :stability: experimental
+        '''
+        result = self._values.get("environment")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
+
+    @builtins.property
+    def lambda_function_options(self) -> typing.Any:
+        '''(experimental) Can be used to override the default lambda function properties.
+
+        :default: - defined in the construct.
+
+        :stability: experimental
+        '''
+        result = self._values.get("lambda_function_options")
+        return typing.cast(typing.Any, result)
+
+    @builtins.property
+    def lambda_runtime(self) -> typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime]:
+        '''(experimental) The lambda runtime to use for the item loading function.
+
+        The function is implemented in Python and uses pypgstac for database
+        operations. Ensure the runtime version is compatible with the pgstac
+        version specified in the database configuration.
+
+        :default: lambda.Runtime.PYTHON_3_11
+
+        :stability: experimental
+        '''
+        result = self._values.get("lambda_runtime")
+        return typing.cast(typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime], result)
+
+    @builtins.property
+    def lambda_timeout_seconds(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) The timeout for the item load lambda in seconds.
+
+        This should accommodate the time needed to process up to ``batchSize``
+        objects and perform database insertions. The SQS visibility timeout
+        will be set to this value plus 10 seconds.
+
+        :default: 300
+
+        :stability: experimental
+        '''
+        result = self._values.get("lambda_timeout_seconds")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def max_batching_window_minutes(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) Maximum batching window in minutes.
+
+        Even if the batch size isn't reached, the lambda will be triggered
+        after this time period to ensure timely processing of objects.
+        This prevents objects from waiting indefinitely in low-volume scenarios.
+
+        **Important**: This timeout works in conjunction with batchSize - SQS
+        will trigger the Lambda when EITHER the batch size is reached OR this
+        time window expires, ensuring objects are processed in a timely manner
+        regardless of volume.
+
+        :default: 1
+
+        :stability: experimental
+        '''
+        result = self._values.get("max_batching_window_minutes")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def max_concurrency(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) Maximum concurrent executions for the StacLoader Lambda function.
+
+        This limit will be applied to the Lambda function and will control how
+        many concurrent batches will be released from the SQS queue.
+
+        :default: 2
+
+        :stability: experimental
+        '''
+        result = self._values.get("max_concurrency")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def memory_size(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) Memory size for the lambda function in MB.
+
+        Higher memory allocation may improve performance when processing
+        large batches of STAC objects, especially for memory-intensive
+        database operations.
+
+        :default: 1024
+
+        :stability: experimental
+        '''
+        result = self._values.get("memory_size")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def subnet_selection(
+        self,
+    ) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection]:
+        '''(experimental) Subnet into which the lambda should be deployed.
+
+        :stability: experimental
+        '''
+        result = self._values.get("subnet_selection")
+        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection], result)
+
+    @builtins.property
+    def vpc(self) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc]:
+        '''(experimental) VPC into which the lambda should be deployed.
+
+        :stability: experimental
+        '''
+        result = self._values.get("vpc")
+        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "StacItemLoaderProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 __all__ = [
     "BastionHost",
     "BastionHostProps",
@@ -4399,6 +4742,8 @@ __all__ = [
     "StacIngestorProps",
     "StacItemLoader",
     "StacItemLoaderProps",
+    "StacLoader",
+    "StacLoaderProps",
     "StactoolsItemGenerator",
     "StactoolsItemGeneratorProps",
     "TiPgApiLambda",
@@ -4743,7 +5088,7 @@ def _typecheckingstub__e3a57d9ce730427c9464d66460707367708eb0bc9a9f69fbe2eb0cdbf
     """Type checking stubs"""
     pass
 
-def _typecheckingstub__3993e1684b5582edef005457882c4cfe3c53062e1f47dc584d35a9cfa71c31e0(
+def _typecheckingstub__07e7381e15a2bb6d7b4a36ff70efaaf4a44e5bcce99a053eb5c48cb9dfca728d(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
     *,
@@ -4762,7 +5107,7 @@ def _typecheckingstub__3993e1684b5582edef005457882c4cfe3c53062e1f47dc584d35a9cfa
     """Type checking stubs"""
     pass
 
-def _typecheckingstub__4bbe16b8ca579680ab8c75903813675de5c4f4e8877137194262298af5f8093d(
+def _typecheckingstub__f4ba6b725ddd9c1870cc4cb313a955d81ffb068eda41ee786161dacf35a03192(
     *,
     pgstac_db: PgStacDatabase,
     batch_size: typing.Optional[jsii.Number] = None,
@@ -4882,3 +5227,39 @@ def _typecheckingstub__1ae429080881692eda11326adbfaae8dacaec10c61b4af3a038e97d46
 ) -> None:
     """Type checking stubs"""
     pass
+
+def _typecheckingstub__3993e1684b5582edef005457882c4cfe3c53062e1f47dc584d35a9cfa71c31e0(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    pgstac_db: PgStacDatabase,
+    batch_size: typing.Optional[jsii.Number] = None,
+    environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    lambda_function_options: typing.Any = None,
+    lambda_runtime: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime] = None,
+    lambda_timeout_seconds: typing.Optional[jsii.Number] = None,
+    max_batching_window_minutes: typing.Optional[jsii.Number] = None,
+    max_concurrency: typing.Optional[jsii.Number] = None,
+    memory_size: typing.Optional[jsii.Number] = None,
+    subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
+    vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__4bbe16b8ca579680ab8c75903813675de5c4f4e8877137194262298af5f8093d(
+    *,
+    pgstac_db: PgStacDatabase,
+    batch_size: typing.Optional[jsii.Number] = None,
+    environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    lambda_function_options: typing.Any = None,
+    lambda_runtime: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Runtime] = None,
+    lambda_timeout_seconds: typing.Optional[jsii.Number] = None,
+    max_batching_window_minutes: typing.Optional[jsii.Number] = None,
+    max_concurrency: typing.Optional[jsii.Number] = None,
+    memory_size: typing.Optional[jsii.Number] = None,
+    subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
+    vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
+) -> None:
+    """Type checking stubs"""
+    pass

{eoapi_cdk-8.2.2 → eoapi_cdk-8.3.0}/src/eoapi_cdk/_jsii/__init__.py

@@ -32,7 +32,7 @@ import aws_cdk._jsii
 import constructs._jsii
 
 __jsii_assembly__ = jsii.JSIIAssembly.load(
-    "eoapi-cdk", "8.2.2", __name__[0:-6], "eoapi-cdk@8.2.2.jsii.tgz"
+    "eoapi-cdk", "8.3.0", __name__[0:-6], "eoapi-cdk@8.3.0.jsii.tgz"
 )
 
 __all__ = [

{eoapi_cdk-8.2.2 → eoapi_cdk-8.3.0/src/eoapi_cdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eoapi-cdk
-Version: 8.2.2
+Version: 8.3.0
 Summary: A set of constructs deploying pgSTAC with CDK
 Home-page: https://github.com/developmentseed/eoapi-cdk.git
 Author: Anthony Lukach<anthony@developmentseed.org>

{eoapi_cdk-8.2.2 → eoapi_cdk-8.3.0}/src/eoapi_cdk.egg-info/SOURCES.txt

@@ -11,4 +11,4 @@ src/eoapi_cdk.egg-info/dependency_links.txt
 src/eoapi_cdk.egg-info/requires.txt
 src/eoapi_cdk.egg-info/top_level.txt
 src/eoapi_cdk/_jsii/__init__.py
-src/eoapi_cdk/_jsii/eoapi-cdk@8.2.2.jsii.tgz
+src/eoapi_cdk/_jsii/eoapi-cdk@8.3.0.jsii.tgz