@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/ProjectionMapper.res

@@ -0,0 +1,44 @@
+// functor to create specific Mapper for projections
+module Spec = Reventless.Projection
+
+module type StateTarget = {
+  let name: string
+  @schema
+  type state
+}
+
+module MakeGenericTargetFromStateTarget = (StateTarget: StateTarget): (
+  Mapper.GenericTarget with type t = StateTarget.state
+) => {
+  let name = StateTarget.name
+  type t = StateTarget.state
+  let decode = json => json->Message.decode(StateTarget.stateSchema)
+  let encode = value => value->Message.encode(StateTarget.stateSchema)
+}
+
+module Make = (
+  Target: Reventless.Projection.Target,
+  Mappings: Reventless.Projection.Mappings with module Target := Target,
+): (
+  MapperNto1.Mapper
+    with type targetState := Target.state
+    and type action<'id, 'state> := Spec.action<string, Target.state>
+) => {
+  module GenericTarget = MakeGenericTargetFromStateTarget(Target)
+  module GenericMappings = {
+    module type Mapping = MapperNto1.Mapping
+      with module Spec := Spec
+      and type target := Target.state
+
+    let mappings: array<module(Mapping)> = Mappings.mappings->Array.map((module(M)) => {
+      module GenericMapping = {
+        let sourceName = M.sourceName
+        let acceptedTags = Reventless.DcbTag.extractAllVariantNames(M.sourceEventSchema)
+        module Source = Projection.Mapping.MakeGenericSource(M)
+        let project = MapperNto1.makeGenericMap(Source.decode', M.project)
+      }
+      module(GenericMapping: Mapping)
+    })
+  }
+  include MapperNto1.Mapper(Spec, GenericTarget, GenericMappings)
+}

package/src/ProjectionMapper.res.mjs

@@ -0,0 +1,51 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$ReventlessCore from "./Message.res.mjs";
+import * as MapperNto1$ReventlessCore from "./MapperNto1.res.mjs";
+import * as Projection$ReventlessCore from "./Projection.res.mjs";
+
+function MakeGenericTargetFromStateTarget(StateTarget) {
+  let decode = json => Message$ReventlessCore.decode(json, StateTarget.stateSchema);
+  let encode = value => Message$ReventlessCore.encode(value, StateTarget.stateSchema);
+  return {
+    name: StateTarget.name,
+    decode: decode,
+    encode: encode
+  };
+}
+
+function Make(Target) {
+  return Mappings => {
+    let decode = json => Message$ReventlessCore.decode(json, Target.stateSchema);
+    let encode = value => Message$ReventlessCore.encode(value, Target.stateSchema);
+    let GenericTarget_name = Target.name;
+    let GenericTarget = {
+      name: GenericTarget_name,
+      decode: decode,
+      encode: encode
+    };
+    let mappings = Mappings.mappings.map(M => {
+      let acceptedTags = DcbTag$Reventless.extractAllVariantNames(M.sourceEventSchema);
+      let Source = Projection$ReventlessCore.Mapping.MakeGenericSource(M);
+      let project = MapperNto1$ReventlessCore.makeGenericMap(Source.decode$p, M.project);
+      return {
+        sourceName: M.sourceName,
+        acceptedTags: acceptedTags,
+        project: project
+      };
+    });
+    return MapperNto1$ReventlessCore.Mapper({})(GenericTarget)({
+      mappings: mappings
+    });
+  };
+}
+
+let Spec;
+
+export {
+  Spec,
+  MakeGenericTargetFromStateTarget,
+  Make,
+}
+/* DcbTag-Reventless Not a pure module */

package/src/RequestContext.res

@@ -0,0 +1,42 @@
+// RequestContext service — carries per-invocation data through an Effect pipeline
+// without explicit argument threading.
+//
+// Populated at the Lambda handler entry point from the incoming event's meta field.
+// All Effects that need correlationId or identity use serviceWith(RequestContext.tag, ...)
+// instead of accepting them as function arguments.
+//
+// Provide in Lambda handler:
+//   let ctx = { correlationId: event.meta.correlationId, identity: Identity.anonymous, claims: Dict.make() }
+//   myEffect
+//   ->Effect.provideService(RequestContext.tag, ctx)
+//   ->Effect.runPromise
+//
+// In tests:
+//   ->Effect.provideService(RequestContext.tag, RequestContext.test())
+
+type t = {
+  correlationId: string,
+  identity: Reventless.Identity.t,
+  claims: dict<string>,
+}
+
+let tag: Context.tag<t> = Context.genericTag("reventless/RequestContext")
+
+let getClaim = (ctx: t, key: string): option<string> =>
+  ctx.claims->Dict.get(key)
+
+let withClaim = (ctx: t, key: string, value: string): t => {
+  let next = ctx.claims->Dict.toArray->Dict.fromArray
+  next->Dict.set(key, value)
+  {...ctx, claims: next}
+}
+
+let test = (
+  ~correlationId="test-correlation-id",
+  ~identity=Reventless.Identity.anonymous,
+  ~claims=Dict.make(),
+): t => {
+  correlationId,
+  identity,
+  claims,
+}

package/src/RequestContext.res.mjs

@@ -0,0 +1,39 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Context from "effect/Context";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+
+let tag = Context.GenericTag("reventless/RequestContext");
+
+function getClaim(ctx, key) {
+  return ctx.claims[key];
+}
+
+function withClaim(ctx, key, value) {
+  let next = Object.fromEntries(Object.entries(ctx.claims));
+  next[key] = value;
+  return {
+    correlationId: ctx.correlationId,
+    identity: ctx.identity,
+    claims: next
+  };
+}
+
+function test(correlationIdOpt, identityOpt, claimsOpt) {
+  let correlationId = correlationIdOpt !== undefined ? correlationIdOpt : "test-correlation-id";
+  let identity = identityOpt !== undefined ? identityOpt : Identity$Reventless.anonymous;
+  let claims = claimsOpt !== undefined ? claimsOpt : ({});
+  return {
+    correlationId: correlationId,
+    identity: identity,
+    claims: claims
+  };
+}
+
+export {
+  tag,
+  getClaim,
+  withClaim,
+  test,
+}
+/* tag Not a pure module */

package/src/adapter/Adapter.res

@@ -0,0 +1,178 @@
+let log = Logger.fromEnv()
+
+type resolvedResource = ReventlessInfra.Adapter.resolvedResource
+
+let outputToResource: Pulumi.Output.t<
+  ReventlessInfra.Adapter.resource,
+> => ReventlessInfra.Adapter.resource = resourceOutput => {
+  id: resourceOutput->Pulumi.Output.flatMap(r => r.id),
+  name: resourceOutput->Pulumi.Output.flatMap(r => r.name),
+  urn: resourceOutput->Pulumi.Output.flatMap(r => r.urn),
+  resourceInfo: resourceOutput->Pulumi.Output.flatMap(r => r.resourceInfo),
+  service: resourceOutput->Pulumi.Output.flatMap(r => r.service),
+  role: resourceOutput->Pulumi.Output.flatMap(r => r.role),
+  region: resourceOutput->Pulumi.Output.flatMap(r => r.region),
+  resourceType: resourceOutput->Pulumi.Output.flatMap(r => r.resourceType),
+  configuration: resourceOutput->Pulumi.Output.flatMap(r => r.configuration),
+  tags: resourceOutput->Pulumi.Output.flatMap(r => r.tags),
+}
+
+let resourcesOutputToResource: Pulumi.Output.t<array<ReventlessInfra.Adapter.resource>> => option<
+  ReventlessInfra.Adapter.resource,
+> = resourcesOutput =>
+  try {
+    id: resourcesOutput->Pulumi.Output.flatMap(r => (r->Array.getUnsafe(0)).id),
+    name: resourcesOutput->Pulumi.Output.flatMap(r => (r->Array.getUnsafe(0)).name),
+    urn: resourcesOutput->Pulumi.Output.flatMap(r => (r->Array.getUnsafe(0)).urn),
+    resourceInfo: resourcesOutput->Pulumi.Output.flatMap(r => (r->Array.getUnsafe(0)).resourceInfo),
+    service: resourcesOutput->Pulumi.Output.flatMap(r => (r->Array.getUnsafe(0)).service),
+    role: resourcesOutput->Pulumi.Output.flatMap(r => (r->Array.getUnsafe(0)).role),
+    region: resourcesOutput->Pulumi.Output.flatMap(r => (r->Array.getUnsafe(0)).region),
+    resourceType: resourcesOutput->Pulumi.Output.flatMap(r => (r->Array.getUnsafe(0)).resourceType),
+    configuration: resourcesOutput->Pulumi.Output.flatMap(r =>
+      (r->Array.getUnsafe(0)).configuration
+    ),
+    tags: resourcesOutput->Pulumi.Output.flatMap(r => (r->Array.getUnsafe(0)).tags),
+  }->Some catch {
+  | _ => None
+  }
+
+let resolvedToResource = (
+  {id, name, urn, resourceInfo, service, role, region, resourceType, configuration, tags}: resolvedResource,
+): ReventlessInfra.Adapter.resource => {
+  id: id->Pulumi.Output.make,
+  name: name->Pulumi.Output.make,
+  urn: urn->Pulumi.Output.make,
+  resourceInfo: resourceInfo->Pulumi.Output.make,
+  service: service->Pulumi.Output.make,
+  role: role->Pulumi.Output.make,
+  region: region->Pulumi.Output.make,
+  resourceType: resourceType->Pulumi.Output.make,
+  configuration: configuration->Pulumi.Output.make,
+  tags: tags->Pulumi.Output.make,
+}
+
+let resolvedToResources = (resolved: array<resolvedResource>) =>
+  resolved->Array.map(resolved => resolved->resolvedToResource)
+
+let resolvedOutputToResource: Pulumi.Output.t<
+  resolvedResource,
+> => ReventlessInfra.Adapter.resource = resolvedResource => {
+  service: resolvedResource->Pulumi.Output.apply(r => r.service),
+  name: resolvedResource->Pulumi.Output.apply(r => r.name),
+  id: resolvedResource->Pulumi.Output.apply(r => r.id),
+  urn: resolvedResource->Pulumi.Output.apply(r => r.urn),
+  resourceInfo: resolvedResource->Pulumi.Output.apply(r => r.resourceInfo),
+  role: resolvedResource->Pulumi.Output.apply(r => r.role),
+  region: resolvedResource->Pulumi.Output.apply(r => r.region),
+  resourceType: resolvedResource->Pulumi.Output.apply(r => r.resourceType),
+  configuration: resolvedResource->Pulumi.Output.apply(r => r.configuration),
+  tags: resolvedResource->Pulumi.Output.apply(r => r.tags),
+}
+
+let resourceToResolvedOutput = (r: ReventlessInfra.Adapter.resource) =>
+  (r.name, r.id, r.urn, r.resourceInfo, r.service, r.role)
+  ->Pulumi.Output.all6
+  ->Pulumi.Output.flatMap(((name, id, urn, resourceInfo, service, role)) =>
+    (r.region, r.resourceType, r.configuration, r.tags)
+    ->Pulumi.Output.all4
+    ->Pulumi.Output.apply(((region, resourceType, configuration, tags)) => {
+      let result: resolvedResource = {
+        name,
+        id,
+        urn,
+        resourceInfo,
+        service,
+        role,
+        region,
+        resourceType,
+        configuration,
+        tags,
+      }
+      result
+    })
+  )
+
+let resourcesToResolvedOutput = (resources: array<ReventlessInfra.Adapter.resource>) =>
+  resources
+  ->Array.map(resource => resource->resourceToResolvedOutput)
+  ->Pulumi.Output.all
+
+let logResource = r => {
+  let _ =
+    r
+    ->resourceToResolvedOutput
+    ->Pulumi.Output.apply(r =>
+      log.debug(
+        ~comp="Adapter",
+        ~data=r->JSON.stringifyAny->Option.getOr("")->JSON.Encode.string,
+        "resource",
+      )
+    )
+}
+
+let resolvedToString = (resources: array<resolvedResource>) => {
+  resources->Array.filterMap(resource => resource->JSON.stringifyAny)->Array.joinUnsafe(", ")
+}
+
+let urns = resources => resources->Array.map((resource: resolvedResource) => resource.urn)
+
+// ---------------------------------------------------------------------------
+// Interop resource conversions
+// ReventlessInterop.Resource.t and resolvedResource are structurally identical;
+// these helpers bridge the two type-system identities without runtime cost.
+// ---------------------------------------------------------------------------
+
+let toInteropResource = (
+  {name, id, urn, resourceInfo, service, role, region, resourceType, configuration, tags}: resolvedResource,
+): ReventlessInterop.Resource.t => {
+  name,
+  id,
+  urn,
+  resourceInfo: (resourceInfo :> ReventlessInterop.Resource.resourceInfo),
+  service,
+  role,
+  region,
+  resourceType,
+  configuration,
+  tags,
+}
+
+let resourcesToInterop = (resources: array<ReventlessInfra.Adapter.resource>) =>
+  resources
+  ->resourcesToResolvedOutput
+  ->Pulumi.Output.apply(rs => rs->Array.map(toInteropResource))
+
+let fromInteropResolved = (
+  {name, id, urn, resourceInfo, service, role, region, resourceType, configuration, tags}: ReventlessInterop.Resource.t,
+): resolvedResource => {
+  name,
+  id,
+  urn,
+  resourceInfo: (resourceInfo :> ReventlessInfra.Adapter.resourceInfo),
+  service,
+  role,
+  region,
+  resourceType,
+  configuration,
+  tags,
+}
+
+let fromInteropResource = (
+  {name, id, urn, resourceInfo, service, role, region, resourceType, configuration, tags}: ReventlessInterop.Resource.t,
+): ReventlessInfra.Adapter.resource => {
+  id: id->Pulumi.Output.make,
+  name: name->Pulumi.Output.make,
+  urn: urn->Pulumi.Output.make,
+  resourceInfo: (resourceInfo :> ReventlessInfra.Adapter.resourceInfo)->Pulumi.Output.make,
+  service: service->Pulumi.Output.make,
+  role: role->Pulumi.Output.make,
+  region: region->Pulumi.Output.make,
+  resourceType: resourceType->Pulumi.Output.make,
+  configuration: configuration->Pulumi.Output.make,
+  tags: tags->Pulumi.Output.make,
+}
+
+let fromInteropResources = (rs: array<ReventlessInterop.Resource.t>): array<
+  ReventlessInfra.Adapter.resource,
+> => rs->Array.map(fromInteropResource)

package/src/adapter/Adapter.res.mjs

@@ -0,0 +1,201 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Logger$ReventlessCore from "../util/Logger.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function outputToResource(resourceOutput) {
+  return {
+    name: Output$Pulumi.flatMap(resourceOutput, r => r.name),
+    id: Output$Pulumi.flatMap(resourceOutput, r => r.id),
+    urn: Output$Pulumi.flatMap(resourceOutput, r => r.urn),
+    resourceInfo: Output$Pulumi.flatMap(resourceOutput, r => r.resourceInfo),
+    service: Output$Pulumi.flatMap(resourceOutput, r => r.service),
+    role: Output$Pulumi.flatMap(resourceOutput, r => r.role),
+    region: Output$Pulumi.flatMap(resourceOutput, r => r.region),
+    resourceType: Output$Pulumi.flatMap(resourceOutput, r => r.resourceType),
+    configuration: Output$Pulumi.flatMap(resourceOutput, r => r.configuration),
+    tags: Output$Pulumi.flatMap(resourceOutput, r => r.tags)
+  };
+}
+
+function resourcesOutputToResource(resourcesOutput) {
+  try {
+    return {
+      name: Output$Pulumi.flatMap(resourcesOutput, r => r[0].name),
+      id: Output$Pulumi.flatMap(resourcesOutput, r => r[0].id),
+      urn: Output$Pulumi.flatMap(resourcesOutput, r => r[0].urn),
+      resourceInfo: Output$Pulumi.flatMap(resourcesOutput, r => r[0].resourceInfo),
+      service: Output$Pulumi.flatMap(resourcesOutput, r => r[0].service),
+      role: Output$Pulumi.flatMap(resourcesOutput, r => r[0].role),
+      region: Output$Pulumi.flatMap(resourcesOutput, r => r[0].region),
+      resourceType: Output$Pulumi.flatMap(resourcesOutput, r => r[0].resourceType),
+      configuration: Output$Pulumi.flatMap(resourcesOutput, r => r[0].configuration),
+      tags: Output$Pulumi.flatMap(resourcesOutput, r => r[0].tags)
+    };
+  } catch (exn) {
+    return;
+  }
+}
+
+function resolvedToResource(param) {
+  return {
+    name: Pulumi.output(param.name),
+    id: Pulumi.output(param.id),
+    urn: Pulumi.output(param.urn),
+    resourceInfo: Pulumi.output(param.resourceInfo),
+    service: Pulumi.output(param.service),
+    role: Pulumi.output(param.role),
+    region: Pulumi.output(param.region),
+    resourceType: Pulumi.output(param.resourceType),
+    configuration: Pulumi.output(param.configuration),
+    tags: Pulumi.output(param.tags)
+  };
+}
+
+function resolvedToResources(resolved) {
+  return resolved.map(resolvedToResource);
+}
+
+function resolvedOutputToResource(resolvedResource) {
+  return {
+    name: resolvedResource.apply(r => r.name),
+    id: resolvedResource.apply(r => r.id),
+    urn: resolvedResource.apply(r => r.urn),
+    resourceInfo: resolvedResource.apply(r => r.resourceInfo),
+    service: resolvedResource.apply(r => r.service),
+    role: resolvedResource.apply(r => r.role),
+    region: resolvedResource.apply(r => r.region),
+    resourceType: resolvedResource.apply(r => r.resourceType),
+    configuration: resolvedResource.apply(r => r.configuration),
+    tags: resolvedResource.apply(r => r.tags)
+  };
+}
+
+function resourceToResolvedOutput(r) {
+  return Output$Pulumi.flatMap(Pulumi.all([
+    r.name,
+    r.id,
+    r.urn,
+    r.resourceInfo,
+    r.service,
+    r.role
+  ]), param => {
+    let role = param[5];
+    let service = param[4];
+    let resourceInfo = param[3];
+    let urn = param[2];
+    let id = param[1];
+    let name = param[0];
+    return Pulumi.all([
+      r.region,
+      r.resourceType,
+      r.configuration,
+      r.tags
+    ]).apply(param => ({
+      name: name,
+      id: id,
+      urn: urn,
+      resourceInfo: resourceInfo,
+      service: service,
+      role: role,
+      region: param[0],
+      resourceType: param[1],
+      configuration: param[2],
+      tags: param[3]
+    }));
+  });
+}
+
+function resourcesToResolvedOutput(resources) {
+  return Pulumi.all(resources.map(resourceToResolvedOutput));
+}
+
+function logResource(r) {
+  resourceToResolvedOutput(r).apply(r => log.debug("Adapter", Stdlib_Option.getOr(JSON.stringify(r), ""), "resource"));
+}
+
+function resolvedToString(resources) {
+  return Stdlib_Array.filterMap(resources, resource => JSON.stringify(resource)).join(", ");
+}
+
+function urns(resources) {
+  return resources.map(resource => resource.urn);
+}
+
+function toInteropResource(param) {
+  return {
+    name: param.name,
+    id: param.id,
+    urn: param.urn,
+    resourceInfo: param.resourceInfo,
+    service: param.service,
+    role: param.role,
+    region: param.region,
+    resourceType: param.resourceType,
+    configuration: param.configuration,
+    tags: param.tags
+  };
+}
+
+function resourcesToInterop(resources) {
+  return resourcesToResolvedOutput(resources).apply(rs => rs.map(toInteropResource));
+}
+
+function fromInteropResolved(param) {
+  return {
+    name: param.name,
+    id: param.id,
+    urn: param.urn,
+    resourceInfo: param.resourceInfo,
+    service: param.service,
+    role: param.role,
+    region: param.region,
+    resourceType: param.resourceType,
+    configuration: param.configuration,
+    tags: param.tags
+  };
+}
+
+function fromInteropResource(param) {
+  return {
+    name: Pulumi.output(param.name),
+    id: Pulumi.output(param.id),
+    urn: Pulumi.output(param.urn),
+    resourceInfo: Pulumi.output(param.resourceInfo),
+    service: Pulumi.output(param.service),
+    role: Pulumi.output(param.role),
+    region: Pulumi.output(param.region),
+    resourceType: Pulumi.output(param.resourceType),
+    configuration: Pulumi.output(param.configuration),
+    tags: Pulumi.output(param.tags)
+  };
+}
+
+function fromInteropResources(rs) {
+  return rs.map(fromInteropResource);
+}
+
+export {
+  log,
+  outputToResource,
+  resourcesOutputToResource,
+  resolvedToResource,
+  resolvedToResources,
+  resolvedOutputToResource,
+  resourceToResolvedOutput,
+  resourcesToResolvedOutput,
+  logResource,
+  resolvedToString,
+  urns,
+  toInteropResource,
+  resourcesToInterop,
+  fromInteropResolved,
+  fromInteropResource,
+  fromInteropResources,
+}
+/* log Not a pure module */

package/src/adapter/AdapterDeploytime.res

@@ -0,0 +1,56 @@
+let resolvedToResource: Adapter.resolvedResource => ReventlessInfra.Adapter.resource = ({
+  name,
+  id,
+  urn,
+  resourceInfo,
+  service,
+  role,
+  region,
+  resourceType,
+  configuration,
+  tags,
+}) => {
+  name: name->Pulumi.Output.make,
+  id: id->Pulumi.Output.make,
+  urn: urn->Pulumi.Output.make,
+  resourceInfo: resourceInfo->Pulumi.Output.make,
+  service: service->Pulumi.Output.make,
+  role: role->Pulumi.Output.make,
+  region: region->Pulumi.Output.make,
+  resourceType: resourceType->Pulumi.Output.make,
+  configuration: configuration->Pulumi.Output.make,
+  tags: tags->Pulumi.Output.make,
+}
+
+external unsafeUnwrapResource: ReventlessInfra.Adapter.resource => Adapter.resolvedResource =
+  "%identity"
+
+let stackRefResourceToResource = stackRefResource =>
+  stackRefResource->unsafeUnwrapResource->resolvedToResource // StackReference outputs are not wrapped in Pulumi.Outputs !
+
+// Convert from interop Resource.t directly to a Pulumi-wrapped resource.
+// Identical to resolvedToResource but accepts the interop type, avoiding the
+// intermediate Adapter.resolvedResource step.
+let fromInteropResource: ReventlessInterop.Resource.t => ReventlessInfra.Adapter.resource = ({
+  name,
+  id,
+  urn,
+  resourceInfo,
+  service,
+  role,
+  region,
+  resourceType,
+  configuration,
+  tags,
+}) => {
+  name: name->Pulumi.Output.make,
+  id: id->Pulumi.Output.make,
+  urn: urn->Pulumi.Output.make,
+  resourceInfo: (resourceInfo :> ReventlessInfra.Adapter.resourceInfo)->Pulumi.Output.make,
+  service: service->Pulumi.Output.make,
+  role: role->Pulumi.Output.make,
+  region: region->Pulumi.Output.make,
+  resourceType: resourceType->Pulumi.Output.make,
+  configuration: configuration->Pulumi.Output.make,
+  tags: tags->Pulumi.Output.make,
+}

package/src/adapter/AdapterDeploytime.res.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+
+function resolvedToResource(param) {
+  return {
+    name: Pulumi.output(param.name),
+    id: Pulumi.output(param.id),
+    urn: Pulumi.output(param.urn),
+    resourceInfo: Pulumi.output(param.resourceInfo),
+    service: Pulumi.output(param.service),
+    role: Pulumi.output(param.role),
+    region: Pulumi.output(param.region),
+    resourceType: Pulumi.output(param.resourceType),
+    configuration: Pulumi.output(param.configuration),
+    tags: Pulumi.output(param.tags)
+  };
+}
+
+let stackRefResourceToResource = resolvedToResource;
+
+function fromInteropResource(param) {
+  return {
+    name: Pulumi.output(param.name),
+    id: Pulumi.output(param.id),
+    urn: Pulumi.output(param.urn),
+    resourceInfo: Pulumi.output(param.resourceInfo),
+    service: Pulumi.output(param.service),
+    role: Pulumi.output(param.role),
+    region: Pulumi.output(param.region),
+    resourceType: Pulumi.output(param.resourceType),
+    configuration: Pulumi.output(param.configuration),
+    tags: Pulumi.output(param.tags)
+  };
+}
+
+export {
+  resolvedToResource,
+  stackRefResourceToResource,
+  fromInteropResource,
+}
+/* @pulumi/pulumi Not a pure module */