@reventlessdev/rescript-pulumi-aws 2.4.0-alpha.43

package/src/Kinesis/Kinesis.res

@@ -0,0 +1,4 @@
+/** @pulumi/aws/kinesis
+  see: https://www.pulumi.com/registry/packages/aws/api-docs/kinesis
+*/
+module Stream = Kinesis_Stream

package/src/Kinesis/Kinesis.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let Stream;
+
+export {
+  Stream,
+}
+/* No side effect */

package/src/Kinesis/Kinesis_Stream.res

@@ -0,0 +1,70 @@
+/** @pulumi/aws/kinesis/Stream
+  see: https://www.pulumi.com/registry/packages/aws/api-docs/kinesis/stream
+*/
+type t = {arn: Pulumi.Output.t<string>, name: Pulumi.Output.t<string>}
+type stream = t
+
+type args = {
+  arn?: Pulumi.Input.t<string>,
+  encryptionType?: Pulumi.Input.t<string>,
+  kmsKeyId?: Pulumi.Input.t<string>,
+  name?: Pulumi.Input.t<string>,
+  retentionPeriod?: Pulumi.Input.t<int>,
+  shardCount?: Pulumi.Input.t<int>,
+  shardLevelMetrics?: Pulumi.Input.t<array<string>>,
+  tags?: Pulumi.Input.t<Aws.tags>,
+}
+
+type info = {
+  data: string,
+  kinesisSchemaVersion: string,
+  partitionKey: string,
+  sequenceNumber: string,
+}
+
+type record = {
+  awsRegion: string,
+  eventID: string,
+  eventName: string,
+  eventSource: string,
+  eventSourceARN: string,
+  eventVersion: string,
+  invokeIdentityArn: string,
+  kinesis: info,
+}
+
+type event = {@as("Records") records: array<record>}
+
+type handler = Lambda.eventHandlerNoResult<event>
+
+type subscriptionArgs = {
+  startingPosition: Pulumi.Input.t<string>, //TODO enums
+  batchSize?: Pulumi.Input.t<int>,
+  startingPositionTimestamp?: Pulumi.Input.t<string>,
+}
+
+module EventSubscription = {
+  type t = {
+    name: string,
+    stream: stream,
+    handler: handler,
+    args: subscriptionArgs,
+    opts?: Pulumi.CustomResourceOptions.t,
+  }
+}
+
+@module("@pulumi/aws") @scope("kinesis") @new
+external make: (
+  ~name: string,
+  ~args: args=?,
+  ~opts: Pulumi.CustomResourceOptions.t=?
+) => stream = "Stream"
+
+@send
+external onEvent: (
+  stream,
+  ~name: string,
+  ~handler: Lambda.eventHandlerNoResult<event>,
+  ~args: subscriptionArgs=?,
+  ~opts: Pulumi.CustomResourceOptions.t=?
+) => EventSubscription.t = "onEvent"

package/src/Kinesis/Kinesis_Stream.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let EventSubscription = {};
+
+export {
+  EventSubscription,
+}
+/* No side effect */

package/src/Lambda/EventSourceMapping.res

@@ -0,0 +1,78 @@
+/** @pulumi/aws/lambda/eventsourcemapping
+  see: https://www.pulumi.com/registry/packages/aws/api-docs/lambda/eventsourcemapping/
+ */
+type onFailure = {destinationArn: Pulumi.Input.t<string>}
+
+type destinationConfig = {onFailure: onFailure}
+
+type functionResponseType = ReportBatchItemFailures
+
+type startingPosition = AT_TIMESTAMP | LATEST | TRIM_HORIZON
+
+/** construct an eventSourceMappingsArgs object
+   
+    functionName: The name or the ARN of the Lambda function that will be subscribing to events.
+   
+    batchSize: The largest number of records that Lambda will retrieve from your event source at the time of invocation.
+    Defaults to 100 for DynamoDB, Kinesis, MQ and MSK, 10 for SQS.
+   
+    bisectBatchOnFunctionError: If the function returns an error, split the batch in two and retry.
+    Only available for stream sources (DynamoDB and Kinesis). Defaults to false.
+   
+    enabled: Determines if the mapping will be enabled on creation. Defaults to true.
+   
+    eventSourceArn: The event source ARN - this is required for Kinesis stream, DynamoDB stream, SQS queue, MQ broker or MSK cluster.
+    It is incompatible with a Self Managed Kafka source.
+   
+    functionResponseTypes: A list of current response type enums applied to the event source mapping for AWS Lambda checkpointing.
+    Only available for stream sources (DynamoDB and Kinesis). Valid values: ReportBatchItemFailures.
+   
+    maximumBatchingWindowInSeconds: The maximum amount of time to gather records before invoking the function, in seconds (between 0 and 300).
+    Records will continue to buffer (or accumulate in the case of an SQS queue event source) until either maximumBatchingWindowInSeconds expires or batchSize has been met.
+   
+    maximumRecordAgeInSeconds: The maximum age of a record that Lambda sends to a function for processing.
+    Only available for stream sources (DynamoDB and Kinesis). Must be either -1 (forever, and the default value) or between 60 and 604800 (inclusive).
+   
+    maximumRetryAttempts: The maximum number of times to retry when the function returns an error.
+    Only available for stream sources (DynamoDB and Kinesis). Minimum and default of -1 (forever), maximum of 10000.
+   
+    parallelizationFactor: The number of batches to process from each shard concurrently.
+    Only available for stream sources (DynamoDB and Kinesis). Minimum and default of 1, maximum of 10.
+   
+    startingPosition: The position in the stream where AWS Lambda should start reading.
+    Must be one of AT_TIMESTAMP (Kinesis only), LATEST or TRIM_HORIZON if getting events from Kinesis, DynamoDB or MSK. Must not be provided if getting events from SQS.
+   
+    startingPositionTimestamp: A timestamp in RFC3339 format of the data record which to start reading when using starting_position set to AT_TIMESTAMP.
+    If a record with this exact timestamp does not exist, the next later record is chosen.
+    If the timestamp is older than the current trim horizon, the oldest available record is chosen.
+   
+    tumblingWindowInSeconds: The duration in seconds of a processing window for AWS Lambda streaming analytics.
+    The range is between 1 second up to 900 seconds. Only available for stream sources (DynamoDB and Kinesis).
+   */
+type args = {
+  functionName: Pulumi.Input.t<string>,
+  batchSize?: int,
+  bisectBatchOnFunctionError?: bool,
+  destinationConfig?: destinationConfig,
+  enabled?: bool,
+  eventSourceArn?: Pulumi.Input.t<string>,
+  functionResponseTypes?: array<functionResponseType>,
+  maximumBatchingWindowInSeconds?: int,
+  maximumRecordAgeInSeconds?: int,
+  maximumRetryAttempts?: int,
+  parallelizationFactor?: int,
+  startingPosition?: startingPosition,
+  startingPositionTimestamp?: Pulumi.Input.t<string>,
+  tumblingWindowInSeconds?: int,
+}
+
+type t = {
+  id: Pulumi.Output.t<string>,
+  arn: Pulumi.Output.t<string>,
+  batchSize: Pulumi.Output.t<int>,
+  enabled: Pulumi.Output.t<bool>,
+}
+
+@module("@pulumi/aws") @scope("lambda") @new
+external make: (~name: string, ~args: args, ~opts: option<Pulumi.CustomResourceOptions.t>) => t =
+  "EventSourceMapping"

package/src/Lambda/EventSourceMapping.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/Lambda/FunctionUrl.res

@@ -0,0 +1,41 @@
+/** @pulumi/aws/lambda/functionurl
+  see: https://www.pulumi.com/registry/packages/aws/api-docs/lambda/functionurl/
+*/
+type authorizationType =
+  | @as("AWS_IAM") AwsIam
+  | @as("NONE") None
+
+type invokeMode =
+  | @as("BUFFERED") Buffered
+  | @as("RESPONSE_STREAM") ResponseStream
+
+type cors = {
+  allowCredentials?: Pulumi.Input.t<bool>,
+  allowHeaders?: Pulumi.Input.t<array<Pulumi.Input.t<string>>>,
+  allowMethods?: Pulumi.Input.t<array<Pulumi.Input.t<string>>>,
+  allowOrigins?: Pulumi.Input.t<array<Pulumi.Input.t<string>>>,
+  exposeHeaders?: Pulumi.Input.t<array<Pulumi.Input.t<string>>>,
+  maxAge?: Pulumi.Input.t<int>,
+}
+
+type args = {
+  authorizationType: authorizationType,
+  functionName: Pulumi.Input.t<string>,
+  cors?: Pulumi.Input.t<cors>,
+  invokeMode?: invokeMode,
+  qualifier?: Pulumi.Input.t<string>,
+}
+
+type t = {
+  functionArn: Pulumi.Output.t<string>,
+  functionUrl: Pulumi.Output.t<string>,
+  urlId: Pulumi.Output.t<string>,
+}
+
+@module("@pulumi/aws") @scope("lambda") @new
+external make: (~name: string, ~args: args, ~opts: Pulumi.CustomResourceOptions.t=?) => t =
+  "FunctionUrl"
+
+@module("@pulumi/aws") @scope(("lambda", "FunctionUrl"))
+external get: (~name: string, ~id: Pulumi.Input.t<string>, ~opts: Pulumi.CustomResourceOptions.t=?) => t =
+  "get"

package/src/Lambda/FunctionUrl.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/Lambda/Lambda.res

@@ -0,0 +1,270 @@
+/** @pulumi/aws/lambda
+  see: https://www.pulumi.com/registry/packages/aws/api-docs/lambda
+*/
+type cognitoIdentity = {cognitoIdentityId: string, cognitoIdentityPoolId: string}
+
+type clientContextClient = {
+  installationId: string,
+  appTitle: string,
+  appVersionName: string,
+  appVersionCode: string,
+  appPackageName: string,
+}
+
+type clientContextEnv = {
+  platformVersion: string,
+  platform: string,
+  make: string,
+  model: string,
+  locale: string,
+}
+
+type clientContext = {
+  client: clientContextClient,
+  @as("Custom") custom: option<JSON.t>,
+  env: clientContextEnv,
+}
+
+type context = {
+  callbackWaitsForEmptyEventLoop: bool,
+  functionName: string,
+  functionVersion: string,
+  invokedFunctionArn: string,
+  memoryLimitInMB: int,
+  awsRequestId: string,
+  logGroupName: string,
+  logStreamName: string,
+  identity?: cognitoIdentity,
+  clientContext?: clientContext,
+}
+
+type userIdentity = {principalId: string}
+
+type eventHandler<'event, 'result> = ('event, context) => promise<'result>
+type eventHandlerNoResult<'event> = eventHandler<'event, unit>
+
+@send
+external getRemainingTimeInMillis: context => int = "getRemainingTimeInMillis"
+
+@val @scope(("process", "env")) external _layerArnEnv: option<string> = "REVENTLESS_LAYER_ARN"
+@val @scope(("process", "env")) external _pulumiNodejsStack: option<string> = "PULUMI_NODEJS_STACK"
+@module("child_process") external _execSync: (string, {..}) => string = "execSync"
+
+// SSM fallback for local `pulumi up`. CI exports `REVENTLESS_LAYER_ARN`
+// directly (deploy-reventless-aws.yml reads `/reventless/layer-arn/{stack}`
+// via the AWS CLI and injects it as an env var); local devs typically don't.
+// When the env var is unset, shell out to the same SSM parameter from the
+// dev's `aws` CLI so local deploys attach the freshest layer automatically.
+//
+// Failures are swallowed (no `aws` on PATH, missing IAM `ssm:GetParameter`,
+// parameter absent, etc.) — Lambdas then deploy without the layer, which is
+// the same outcome as before this fallback existed.
+let _resolveLayerArnFromSsm = (): option<string> =>
+  switch _pulumiNodejsStack {
+  | None | Some("") => None
+  | Some(stack) =>
+    try {
+      let cmd = `aws ssm get-parameter --name /reventless/layer-arn/${stack} --query Parameter.Value --output text 2>/dev/null`
+      let raw = _execSync(cmd, {"encoding": "utf8"})
+      let trimmed = raw->String.trim
+      if trimmed === "" || trimmed === "None" {
+        None
+      } else {
+        Some(trimmed)
+      }
+    } catch {
+    | _ => None
+    }
+  }
+
+/**
+ * Reventless Lambda layer ARN for the current Pulumi stack.
+ *
+ * Resolution order:
+ *   1. `REVENTLESS_LAYER_ARN` env var — fast path, used by CI
+ *      (deploy-reventless-aws.yml reads SSM and exports it).
+ *   2. AWS CLI SSM lookup at `/reventless/layer-arn/${PULUMI_NODEJS_STACK}` —
+ *      local-deploy convenience so devs don't need to export the env var
+ *      manually.
+ *   3. `None` when both fail — Lambdas deploy without the layer.
+ */
+let reventlessLayerArn: option<string> =
+  switch _layerArnEnv {
+  | Some(arn) if arn->String.trim->String.length > 0 => Some(arn->String.trim)
+  | _ => _resolveLayerArnFromSsm()
+  }
+
+@val
+external environment: option<string> = "process.env.Environment"
+
+module CallbackFunction = {
+  module Args = {
+    type deadLetterConfig = {targetArn: string}
+
+    type mode = Active | PassThrough
+    type tracingConfig = {mode: mode}
+
+    type vpcConfig = {
+      securityGroupIds: array<string>,
+      subnetIds: array<string>,
+      vpcId?: string,
+    }
+
+    type functionEnvironment = {variables?: dict<string>}
+
+    /**
+      Default node runtime: 22
+     */
+    type runtime =
+      | @as("nodejs20.x") NodeJs20
+      | @as("nodejs22.x") NodeJs22
+
+    type t<'event, 'result> = {
+      callback: eventHandler<'event, 'result>,
+      runtime?: runtime,
+      role?: IAM.Role.t,
+      policies?: string,
+      deadLetterConfig?: Pulumi.Input.t<deadLetterConfig>,
+      tracingConfig?: Pulumi.Input.t<tracingConfig>,
+      memorySize?: Pulumi.Input.t<int>,
+      timeout?: Pulumi.Input.t<int>,
+      layers?: Pulumi.Input.t<array<Pulumi.Input.t<string>>>,
+      vpcConfig?: Pulumi.Input.t<vpcConfig>,
+      tags?: Pulumi.Input.t<Aws.tags>,
+      environment?: functionEnvironment,
+    }
+
+    /**
+      defaults: memorySize=1024, timeout=180, runtime=NodeJs22
+
+      The 1024MB memory default is optimal for Node.js Lambdas with AWS SDK v3,
+      balancing cost and performance. Lower values cause slow cold starts when
+      loading multiple AWS SDK clients; higher values increase cost without
+      significant benefit for most workloads.
+      */
+    let make = (
+      ~callback,
+      ~role=?,
+      ~policies=?,
+      ~deadLetterConfig=?,
+      ~tracingConfig=?,
+      ~memorySize=1024->Pulumi.Input.make,
+      ~timeout=180->Pulumi.Input.make,
+      ~runtime=NodeJs22,
+      ~layers=reventlessLayerArn
+      ->Option.map(arn => [arn->Pulumi.Input.make])
+      ->Option.getOr([])
+      ->Pulumi.Input.make,
+      ~vpcConfig=?,
+      ~tags=?,
+      ~environment={
+        variables: [("Environment", Pulumi.Pulumi.getStackName())]->Dict.fromArray,
+      },
+    ) => {
+      callback,
+      runtime,
+      ?policies,
+      ?deadLetterConfig,
+      ?tracingConfig,
+      ?role,
+      memorySize,
+      timeout,
+      layers,
+      ?vpcConfig,
+      ?tags,
+      environment,
+    }
+  }
+
+  type record = {eventSource: string, eventSourceARN: string}
+  type event = {@as("Records") records: array<record>}
+  type eventHandler = eventHandler<event, unit>
+
+  type t = {
+    arn: Pulumi.Output.t<string>,
+    id: Pulumi.Output.t<string>,
+    name: Pulumi.Output.t<string>,
+  }
+
+  @module("@pulumi/aws") @scope("lambda") @new
+  external make: (
+    ~name: string,
+    ~args: Args.t<'event, 'result>,
+    ~opts: Pulumi.CustomResourceOptions.t=?,
+  ) => t = "CallbackFunction"
+
+  @module("@pulumi/aws") @scope(("lambda", "Function"))
+  external get: (
+    ~name: string,
+    ~id: Pulumi.Input.t<string>,
+    ~opts: Pulumi.CustomResourceOptions.t=?,
+  ) => t = "get"
+}
+
+module Function = {
+  type functionEnvironment = {variables?: dict<Pulumi.Input.t<string>>}
+
+  type ephemeralStorage = {size: Pulumi.Input.t<int>}
+
+  type args = {
+    handler?: Pulumi.Input.t<string>,
+    runtime?: Pulumi.Input.t<string>,
+    code?: Pulumi.Input.t<Pulumi.Archive.t>,
+    role: Pulumi.Input.t<string>,
+    memorySize?: Pulumi.Input.t<int>,
+    timeout?: Pulumi.Input.t<int>,
+    layers?: Pulumi.Input.t<array<Pulumi.Input.t<string>>>,
+    tags?: Pulumi.Input.t<Aws.tags>,
+    environment?: Pulumi.Input.t<functionEnvironment>,
+    sourceCodeHash?: Pulumi.Input.t<string>,
+    reservedConcurrentExecutions?: Pulumi.Input.t<int>,
+    ephemeralStorage?: Pulumi.Input.t<ephemeralStorage>,
+  }
+
+  type t = {
+    arn: Pulumi.Output.t<string>,
+    id: Pulumi.Output.t<string>,
+    name: Pulumi.Output.t<string>,
+    invokeArn: Pulumi.Output.t<string>,
+  }
+
+  @module("@pulumi/aws") @scope("lambda") @new
+  external make: (
+    ~name: string,
+    ~args: args,
+    ~opts: Pulumi.CustomResourceOptions.t=?,
+  ) => t = "Function"
+
+  @module("@pulumi/aws") @scope(("lambda", "Function"))
+  external get: (
+    ~name: string,
+    ~id: Pulumi.Input.t<string>,
+    ~opts: Pulumi.CustomResourceOptions.t=?,
+  ) => t = "get"
+}
+
+module Permission = {
+  type args = {
+    action: string,
+    function: Pulumi.Input.t<string>,
+    principal: string,
+    statementId?: string,
+    sourceArn?: Pulumi.Input.t<string>,
+  }
+
+  type t = {"arn": Pulumi.Output.t<string>, "id": Pulumi.Output.t<string>}
+  @module("@pulumi/aws") @scope("lambda") @new
+  external make: (~name: string, ~args: args, ~opts: Pulumi.CustomResourceOptions.t=?) => t =
+    "Permission"
+}
+
+let defaultLoggingPolicyDocument = PolicyDocument.make(
+  ~statements=[
+    {
+      sid: "DefaultLambdaLoggingPolicy",
+      effect: Allow,
+      actions: Actions(["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"]),
+      resources: Resource("arn:aws:logs:*:*:*"),
+    },
+  ],
+)

package/src/Lambda/Lambda.res.mjs

@@ -0,0 +1,94 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Child_process from "child_process";
+import * as Pulumi from "@pulumi/pulumi";
+import * as PolicyDocument$PulumiAws from "../IAM/PolicyDocument.res.mjs";
+
+function _resolveLayerArnFromSsm() {
+  let stack = process.env.PULUMI_NODEJS_STACK;
+  if (stack === undefined) {
+    return;
+  }
+  if (stack === "") {
+    return;
+  }
+  try {
+    let cmd = `aws ssm get-parameter --name /reventless/layer-arn/` + stack + ` --query Parameter.Value --output text 2>/dev/null`;
+    let raw = Child_process.execSync(cmd, {
+      encoding: "utf8"
+    });
+    let trimmed = raw.trim();
+    if (trimmed === "" || trimmed === "None") {
+      return;
+    } else {
+      return trimmed;
+    }
+  } catch (exn) {
+    return;
+  }
+}
+
+let arn = process.env.REVENTLESS_LAYER_ARN;
+
+let reventlessLayerArn = arn !== undefined && arn.trim().length > 0 ? arn.trim() : _resolveLayerArnFromSsm();
+
+function make(callback, role, policies, deadLetterConfig, tracingConfig, memorySizeOpt, timeoutOpt, runtimeOpt, layersOpt, vpcConfig, tags, environmentOpt) {
+  let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+  let timeout = timeoutOpt !== undefined ? timeoutOpt : 180;
+  let runtime = runtimeOpt !== undefined ? runtimeOpt : "nodejs22.x";
+  let layers = layersOpt !== undefined ? layersOpt : Stdlib_Option.getOr(Stdlib_Option.map(reventlessLayerArn, arn => [arn]), []);
+  let environment = environmentOpt !== undefined ? environmentOpt : ({
+      variables: Object.fromEntries([[
+          "Environment",
+          Pulumi.getStack()
+        ]])
+    });
+  return {
+    callback: callback,
+    runtime: runtime,
+    role: role,
+    policies: policies,
+    deadLetterConfig: deadLetterConfig,
+    tracingConfig: tracingConfig,
+    memorySize: memorySize,
+    timeout: timeout,
+    layers: layers,
+    vpcConfig: vpcConfig,
+    tags: tags,
+    environment: environment
+  };
+}
+
+let Args = {
+  make: make
+};
+
+let CallbackFunction = {
+  Args: Args
+};
+
+let $$Function = {};
+
+let Permission = {};
+
+let defaultLoggingPolicyDocument = PolicyDocument$PulumiAws.make(undefined, undefined, [{
+    Sid: "DefaultLambdaLoggingPolicy",
+    Effect: "Allow",
+    Action: [
+      "logs:CreateLogGroup",
+      "logs:CreateLogStream",
+      "logs:PutLogEvents"
+    ],
+    Resource: "arn:aws:logs:*:*:*"
+  }]);
+
+export {
+  _resolveLayerArnFromSsm,
+  reventlessLayerArn,
+  CallbackFunction,
+  $$Function,
+  Permission,
+  defaultLoggingPolicyDocument,
+}
+/* arn Not a pure module */

package/src/Route53/Route53.res

@@ -0,0 +1,4 @@
+/** @pulumi/aws/route53
+  see: https://www.pulumi.com/registry/packages/aws/api-docs/route53/
+*/
+module Record = Route53_Record

package/src/Route53/Route53.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let Record;
+
+export {
+  Record,
+}
+/* No side effect */

package/src/Route53/Route53_Record.res

@@ -0,0 +1,36 @@
+/** @pulumi/aws/route53/Record
+  see: https://www.pulumi.com/registry/packages/aws/api-docs/route53/record
+
+  Two shapes are supported on the Route53 wire:
+    - **Plain DNS record**: set `records` (and `ttl`); leave `aliases` unset.
+      Used for cert validation (CNAME) and any vanilla A/AAAA/TXT record.
+    - **Alias record**: set `aliases`; leave `records` and `ttl` unset.
+      Used to point a name at a CloudFront distribution / ALB / etc.
+  The two are mutually exclusive in the AWS API; expressed here as two
+  optional fields on a single ReScript type to match the wire shape.
+*/
+type alias = {
+  name: Pulumi.Input.t<string>,
+  zoneId: Pulumi.Input.t<string>,
+  evaluateTargetHealth: Pulumi.Input.t<bool>,
+}
+
+type args = {
+  zoneId: Pulumi.Input.t<string>,
+  name: Pulumi.Input.t<string>,
+  @as("type") type_: Pulumi.Input.t<string>,
+  ttl?: Pulumi.Input.t<int>,
+  records?: Pulumi.Input.t<array<string>>,
+  aliases?: Pulumi.Input.t<array<alias>>,
+  allowOverwrite?: Pulumi.Input.t<bool>,
+}
+
+type t = {
+  id: Pulumi.Output.t<string>,
+  name: Pulumi.Output.t<string>,
+  fqdn: Pulumi.Output.t<string>,
+  zoneId: Pulumi.Output.t<string>,
+}
+
+@module("@pulumi/aws") @scope("route53") @new
+external make: (~name: string, ~args: args, ~opts: Pulumi.CustomResourceOptions.t=?) => t = "Record"

package/src/Route53/Route53_Record.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/S3/S3.res

@@ -0,0 +1,10 @@
+/** @pulumi/aws/s3
+  see: https://www.pulumi.com/registry/packages/aws/api-docs/s3/
+*/
+module Bucket = S3_Bucket
+module BucketV2 = S3_BucketV2
+module BucketAclV2 = S3_BucketAclV2
+module BucketObject = S3_BucketObject
+module BucketOwnershipControls = S3_BucketOwnershipControls
+module BucketPublicAccessBlock = S3_BucketPublicAccessBlock
+module BucketPolicy = S3_BucketPolicy

package/src/S3/S3.res.mjs

@@ -0,0 +1,27 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let Bucket;
+
+let BucketV2;
+
+let BucketAclV2;
+
+let BucketObject;
+
+let BucketOwnershipControls;
+
+let BucketPublicAccessBlock;
+
+let BucketPolicy;
+
+export {
+  Bucket,
+  BucketV2,
+  BucketAclV2,
+  BucketObject,
+  BucketOwnershipControls,
+  BucketPublicAccessBlock,
+  BucketPolicy,
+}
+/* No side effect */