scm.getServiceConnection

import * as pulumi from "@pulumi/pulumi";
import * as scm from "@pulumi/scm";

const config = new pulumi.Config();
// The folder scope for the SCM resource (e.g., 'Shared', 'Predefined', or a specific folder name).
const folderScope = config.get("folderScope") || "Service Connections";
//# 1. Define the IKE Crypto Profile (IKE Phase 1)
// Note: The resource name is plural: "scm_ike_crypto_profile"
const example = new scm.IkeCryptoProfile("example", {
    name: "example-ike-crypto_data",
    folder: folderScope,
    hashes: ["sha256"],
    dhGroups: ["group14"],
    encryptions: ["aes-256-cbc"],
});
//# 2. Define the IPsec Crypto Profile (IKE Phase 2)
// Note: The resource name is plural and nested blocks now use an equals sign (=).
const exampleIpsecCryptoProfile = new scm.IpsecCryptoProfile("example", {
    name: "panw-IPSec-Crypto_data",
    folder: folderScope,
    esp: {
        encryptions: ["aes-256-gcm"],
        authentications: ["sha256"],
    },
    dhGroup: "group14",
    lifetime: {
        hours: 8,
    },
});
//# 3. Define the IKE Gateway
// Note: The resource name is plural and nested blocks now use an equals sign (=).
const exampleIkeGateway = new scm.IkeGateway("example", {
    name: "example-gateway_data",
    folder: folderScope,
    peerAddress: {
        ip: "1.1.1.1",
    },
    authentication: {
        preSharedKey: {
            key: "secret",
        },
    },
    protocol: {
        ikev1: {
            ikeCryptoProfile: example.name,
        },
    },
});
//# 4. Define the IPsec Tunnel
// Note: Nested 'auto_key' block uses an equals sign (=).
const exampleIpsecTunnel = new scm.IpsecTunnel("example", {
    name: "example-tunnel_data",
    folder: folderScope,
    tunnelInterface: "tunnel",
    antiReplay: true,
    copyTos: false,
    enableGreEncapsulation: false,
    autoKey: {
        ikeGateways: [{
            name: exampleIkeGateway.name,
        }],
        ipsecCryptoProfile: exampleIpsecCryptoProfile.name,
    },
}, {
    dependsOn: [exampleIkeGateway],
});
const siteAVpnSc = new scm.ServiceConnection("site_a_vpn_sc", {
    name: "creating_a_service_connection_data",
    region: "us-west-1",
    ipsecTunnel: exampleIpsecTunnel.name,
    subnets: [
        "10.1.0.0/16",
        "172.16.0.0/24",
    ],
    sourceNat: true,
});
//------------------------------------------------------
// Data Soruce
//------------------------------------------------------
const createdConnLookup = scm.getServiceConnectionOutput({
    id: siteAVpnSc.id,
});
export const createdServiceConnectionId = createdConnLookup.apply(createdConnLookup => createdConnLookup.id);
export const createdServiceConnectionRegion = createdConnLookup.apply(createdConnLookup => createdConnLookup.region);
export const createdServiceConnectionSubnets = createdConnLookup.apply(createdConnLookup => createdConnLookup.subnets);

import pulumi
import pulumi_scm as scm

config = pulumi.Config()
# The folder scope for the SCM resource (e.g., 'Shared', 'Predefined', or a specific folder name).
folder_scope = config.get("folderScope")
if folder_scope is None:
    folder_scope = "Service Connections"
## 1. Define the IKE Crypto Profile (IKE Phase 1)
# Note: The resource name is plural: "scm_ike_crypto_profile"
example = scm.IkeCryptoProfile("example",
    name="example-ike-crypto_data",
    folder=folder_scope,
    hashes=["sha256"],
    dh_groups=["group14"],
    encryptions=["aes-256-cbc"])
## 2. Define the IPsec Crypto Profile (IKE Phase 2)
# Note: The resource name is plural and nested blocks now use an equals sign (=).
example_ipsec_crypto_profile = scm.IpsecCryptoProfile("example",
    name="panw-IPSec-Crypto_data",
    folder=folder_scope,
    esp={
        "encryptions": ["aes-256-gcm"],
        "authentications": ["sha256"],
    },
    dh_group="group14",
    lifetime={
        "hours": 8,
    })
## 3. Define the IKE Gateway
# Note: The resource name is plural and nested blocks now use an equals sign (=).
example_ike_gateway = scm.IkeGateway("example",
    name="example-gateway_data",
    folder=folder_scope,
    peer_address={
        "ip": "1.1.1.1",
    },
    authentication={
        "pre_shared_key": {
            "key": "secret",
        },
    },
    protocol={
        "ikev1": {
            "ike_crypto_profile": example.name,
        },
    })
## 4. Define the IPsec Tunnel
# Note: Nested 'auto_key' block uses an equals sign (=).
example_ipsec_tunnel = scm.IpsecTunnel("example",
    name="example-tunnel_data",
    folder=folder_scope,
    tunnel_interface="tunnel",
    anti_replay=True,
    copy_tos=False,
    enable_gre_encapsulation=False,
    auto_key={
        "ike_gateways": [{
            "name": example_ike_gateway.name,
        }],
        "ipsec_crypto_profile": example_ipsec_crypto_profile.name,
    },
    opts = pulumi.ResourceOptions(depends_on=[example_ike_gateway]))
site_a_vpn_sc = scm.ServiceConnection("site_a_vpn_sc",
    name="creating_a_service_connection_data",
    region="us-west-1",
    ipsec_tunnel=example_ipsec_tunnel.name,
    subnets=[
        "10.1.0.0/16",
        "172.16.0.0/24",
    ],
    source_nat=True)
#------------------------------------------------------
# Data Soruce
#------------------------------------------------------
created_conn_lookup = scm.get_service_connection_output(id=site_a_vpn_sc.id)
pulumi.export("createdServiceConnectionId", created_conn_lookup.id)
pulumi.export("createdServiceConnectionRegion", created_conn_lookup.region)
pulumi.export("createdServiceConnectionSubnets", created_conn_lookup.subnets)

package main

import (
	"github.com/pulumi/pulumi-scm/sdk/go/scm"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
cfg := config.New(ctx, "")
// The folder scope for the SCM resource (e.g., 'Shared', 'Predefined', or a specific folder name).
folderScope := "Service Connections";
if param := cfg.Get("folderScope"); param != ""{
folderScope = param
}
//# 1. Define the IKE Crypto Profile (IKE Phase 1)
// Note: The resource name is plural: "scm_ike_crypto_profile"
example, err := scm.NewIkeCryptoProfile(ctx, "example", &scm.IkeCryptoProfileArgs{
Name: pulumi.String("example-ike-crypto_data"),
Folder: pulumi.String(folderScope),
Hashes: pulumi.StringArray{
pulumi.String("sha256"),
},
DhGroups: pulumi.StringArray{
pulumi.String("group14"),
},
Encryptions: pulumi.StringArray{
pulumi.String("aes-256-cbc"),
},
})
if err != nil {
return err
}
//# 2. Define the IPsec Crypto Profile (IKE Phase 2)
// Note: The resource name is plural and nested blocks now use an equals sign (=).
exampleIpsecCryptoProfile, err := scm.NewIpsecCryptoProfile(ctx, "example", &scm.IpsecCryptoProfileArgs{
Name: pulumi.String("panw-IPSec-Crypto_data"),
Folder: pulumi.String(folderScope),
Esp: &scm.IpsecCryptoProfileEspArgs{
Encryptions: pulumi.StringArray{
pulumi.String("aes-256-gcm"),
},
Authentications: pulumi.StringArray{
pulumi.String("sha256"),
},
},
DhGroup: pulumi.String("group14"),
Lifetime: &scm.IpsecCryptoProfileLifetimeArgs{
Hours: pulumi.Int(8),
},
})
if err != nil {
return err
}
//# 3. Define the IKE Gateway
// Note: The resource name is plural and nested blocks now use an equals sign (=).
exampleIkeGateway, err := scm.NewIkeGateway(ctx, "example", &scm.IkeGatewayArgs{
Name: pulumi.String("example-gateway_data"),
Folder: pulumi.String(folderScope),
PeerAddress: &scm.IkeGatewayPeerAddressArgs{
Ip: pulumi.String("1.1.1.1"),
},
Authentication: &scm.IkeGatewayAuthenticationArgs{
PreSharedKey: &scm.IkeGatewayAuthenticationPreSharedKeyArgs{
Key: pulumi.String("secret"),
},
},
Protocol: &scm.IkeGatewayProtocolArgs{
Ikev1: &scm.IkeGatewayProtocolIkev1Args{
IkeCryptoProfile: example.Name,
},
},
})
if err != nil {
return err
}
//# 4. Define the IPsec Tunnel
// Note: Nested 'auto_key' block uses an equals sign (=).
exampleIpsecTunnel, err := scm.NewIpsecTunnel(ctx, "example", &scm.IpsecTunnelArgs{
Name: pulumi.String("example-tunnel_data"),
Folder: pulumi.String(folderScope),
TunnelInterface: pulumi.String("tunnel"),
AntiReplay: pulumi.Bool(true),
CopyTos: pulumi.Bool(false),
EnableGreEncapsulation: pulumi.Bool(false),
AutoKey: &scm.IpsecTunnelAutoKeyArgs{
IkeGateways: scm.IpsecTunnelAutoKeyIkeGatewayArray{
&scm.IpsecTunnelAutoKeyIkeGatewayArgs{
Name: exampleIkeGateway.Name,
},
},
IpsecCryptoProfile: exampleIpsecCryptoProfile.Name,
},
}, pulumi.DependsOn([]pulumi.Resource{
exampleIkeGateway,
}))
if err != nil {
return err
}
siteAVpnSc, err := scm.NewServiceConnection(ctx, "site_a_vpn_sc", &scm.ServiceConnectionArgs{
Name: pulumi.String("creating_a_service_connection_data"),
Region: pulumi.String("us-west-1"),
IpsecTunnel: exampleIpsecTunnel.Name,
Subnets: pulumi.StringArray{
pulumi.String("10.1.0.0/16"),
pulumi.String("172.16.0.0/24"),
},
SourceNat: pulumi.Bool(true),
})
if err != nil {
return err
}
//------------------------------------------------------
// Data Soruce
//------------------------------------------------------
createdConnLookup := scm.LookupServiceConnectionOutput(ctx, scm.GetServiceConnectionOutputArgs{
Id: siteAVpnSc.ID(),
}, nil);
ctx.Export("createdServiceConnectionId", createdConnLookup.ApplyT(func(createdConnLookup scm.GetServiceConnectionResult) (*string, error) {
return &createdConnLookup.Id, nil
}).(pulumi.StringPtrOutput))
ctx.Export("createdServiceConnectionRegion", createdConnLookup.ApplyT(func(createdConnLookup scm.GetServiceConnectionResult) (*string, error) {
return &createdConnLookup.Region, nil
}).(pulumi.StringPtrOutput))
ctx.Export("createdServiceConnectionSubnets", createdConnLookup.ApplyT(func(createdConnLookup scm.GetServiceConnectionResult) (interface{}, error) {
return createdConnLookup.Subnets, nil
}).(pulumi.Interface{}Output))
return nil
})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scm = Pulumi.Scm;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    // The folder scope for the SCM resource (e.g., 'Shared', 'Predefined', or a specific folder name).
    var folderScope = config.Get("folderScope") ?? "Service Connections";
    //# 1. Define the IKE Crypto Profile (IKE Phase 1)
    // Note: The resource name is plural: "scm_ike_crypto_profile"
    var example = new Scm.IkeCryptoProfile("example", new()
    {
        Name = "example-ike-crypto_data",
        Folder = folderScope,
        Hashes = new[]
        {
            "sha256",
        },
        DhGroups = new[]
        {
            "group14",
        },
        Encryptions = new[]
        {
            "aes-256-cbc",
        },
    });

    //# 2. Define the IPsec Crypto Profile (IKE Phase 2)
    // Note: The resource name is plural and nested blocks now use an equals sign (=).
    var exampleIpsecCryptoProfile = new Scm.IpsecCryptoProfile("example", new()
    {
        Name = "panw-IPSec-Crypto_data",
        Folder = folderScope,
        Esp = new Scm.Inputs.IpsecCryptoProfileEspArgs
        {
            Encryptions = new[]
            {
                "aes-256-gcm",
            },
            Authentications = new[]
            {
                "sha256",
            },
        },
        DhGroup = "group14",
        Lifetime = new Scm.Inputs.IpsecCryptoProfileLifetimeArgs
        {
            Hours = 8,
        },
    });

    //# 3. Define the IKE Gateway
    // Note: The resource name is plural and nested blocks now use an equals sign (=).
    var exampleIkeGateway = new Scm.IkeGateway("example", new()
    {
        Name = "example-gateway_data",
        Folder = folderScope,
        PeerAddress = new Scm.Inputs.IkeGatewayPeerAddressArgs
        {
            Ip = "1.1.1.1",
        },
        Authentication = new Scm.Inputs.IkeGatewayAuthenticationArgs
        {
            PreSharedKey = new Scm.Inputs.IkeGatewayAuthenticationPreSharedKeyArgs
            {
                Key = "secret",
            },
        },
        Protocol = new Scm.Inputs.IkeGatewayProtocolArgs
        {
            Ikev1 = new Scm.Inputs.IkeGatewayProtocolIkev1Args
            {
                IkeCryptoProfile = example.Name,
            },
        },
    });

    //# 4. Define the IPsec Tunnel
    // Note: Nested 'auto_key' block uses an equals sign (=).
    var exampleIpsecTunnel = new Scm.IpsecTunnel("example", new()
    {
        Name = "example-tunnel_data",
        Folder = folderScope,
        TunnelInterface = "tunnel",
        AntiReplay = true,
        CopyTos = false,
        EnableGreEncapsulation = false,
        AutoKey = new Scm.Inputs.IpsecTunnelAutoKeyArgs
        {
            IkeGateways = new[]
            {
                new Scm.Inputs.IpsecTunnelAutoKeyIkeGatewayArgs
                {
                    Name = exampleIkeGateway.Name,
                },
            },
            IpsecCryptoProfile = exampleIpsecCryptoProfile.Name,
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleIkeGateway,
        },
    });

    var siteAVpnSc = new Scm.ServiceConnection("site_a_vpn_sc", new()
    {
        Name = "creating_a_service_connection_data",
        Region = "us-west-1",
        IpsecTunnel = exampleIpsecTunnel.Name,
        Subnets = new[]
        {
            "10.1.0.0/16",
            "172.16.0.0/24",
        },
        SourceNat = true,
    });

    //------------------------------------------------------
    // Data Soruce
    //------------------------------------------------------
    var createdConnLookup = Scm.GetServiceConnection.Invoke(new()
    {
        Id = siteAVpnSc.Id,
    });

    return new Dictionary<string, object?>
    {
        ["createdServiceConnectionId"] = createdConnLookup.Apply(getServiceConnectionResult => getServiceConnectionResult.Id),
        ["createdServiceConnectionRegion"] = createdConnLookup.Apply(getServiceConnectionResult => getServiceConnectionResult.Region),
        ["createdServiceConnectionSubnets"] = createdConnLookup.Apply(getServiceConnectionResult => getServiceConnectionResult.Subnets),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scm.IkeCryptoProfile;
import com.pulumi.scm.IkeCryptoProfileArgs;
import com.pulumi.scm.IpsecCryptoProfile;
import com.pulumi.scm.IpsecCryptoProfileArgs;
import com.pulumi.scm.inputs.IpsecCryptoProfileEspArgs;
import com.pulumi.scm.inputs.IpsecCryptoProfileLifetimeArgs;
import com.pulumi.scm.IkeGateway;
import com.pulumi.scm.IkeGatewayArgs;
import com.pulumi.scm.inputs.IkeGatewayPeerAddressArgs;
import com.pulumi.scm.inputs.IkeGatewayAuthenticationArgs;
import com.pulumi.scm.inputs.IkeGatewayAuthenticationPreSharedKeyArgs;
import com.pulumi.scm.inputs.IkeGatewayProtocolArgs;
import com.pulumi.scm.inputs.IkeGatewayProtocolIkev1Args;
import com.pulumi.scm.IpsecTunnel;
import com.pulumi.scm.IpsecTunnelArgs;
import com.pulumi.scm.inputs.IpsecTunnelAutoKeyArgs;
import com.pulumi.scm.ServiceConnection;
import com.pulumi.scm.ServiceConnectionArgs;
import com.pulumi.scm.ScmFunctions;
import com.pulumi.scm.inputs.GetServiceConnectionArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var config = ctx.config();
        final var folderScope = config.get("folderScope").orElse("Service Connections");
        //# 1. Define the IKE Crypto Profile (IKE Phase 1)
        // Note: The resource name is plural: "scm_ike_crypto_profile"
        var example = new IkeCryptoProfile("example", IkeCryptoProfileArgs.builder()
            .name("example-ike-crypto_data")
            .folder(folderScope)
            .hashes("sha256")
            .dhGroups("group14")
            .encryptions("aes-256-cbc")
            .build());

        //# 2. Define the IPsec Crypto Profile (IKE Phase 2)
        // Note: The resource name is plural and nested blocks now use an equals sign (=).
        var exampleIpsecCryptoProfile = new IpsecCryptoProfile("exampleIpsecCryptoProfile", IpsecCryptoProfileArgs.builder()
            .name("panw-IPSec-Crypto_data")
            .folder(folderScope)
            .esp(IpsecCryptoProfileEspArgs.builder()
                .encryptions("aes-256-gcm")
                .authentications("sha256")
                .build())
            .dhGroup("group14")
            .lifetime(IpsecCryptoProfileLifetimeArgs.builder()
                .hours(8)
                .build())
            .build());

        //# 3. Define the IKE Gateway
        // Note: The resource name is plural and nested blocks now use an equals sign (=).
        var exampleIkeGateway = new IkeGateway("exampleIkeGateway", IkeGatewayArgs.builder()
            .name("example-gateway_data")
            .folder(folderScope)
            .peerAddress(IkeGatewayPeerAddressArgs.builder()
                .ip("1.1.1.1")
                .build())
            .authentication(IkeGatewayAuthenticationArgs.builder()
                .preSharedKey(IkeGatewayAuthenticationPreSharedKeyArgs.builder()
                    .key("secret")
                    .build())
                .build())
            .protocol(IkeGatewayProtocolArgs.builder()
                .ikev1(IkeGatewayProtocolIkev1Args.builder()
                    .ikeCryptoProfile(example.name())
                    .build())
                .build())
            .build());

        //# 4. Define the IPsec Tunnel
        // Note: Nested 'auto_key' block uses an equals sign (=).
        var exampleIpsecTunnel = new IpsecTunnel("exampleIpsecTunnel", IpsecTunnelArgs.builder()
            .name("example-tunnel_data")
            .folder(folderScope)
            .tunnelInterface("tunnel")
            .antiReplay(true)
            .copyTos(false)
            .enableGreEncapsulation(false)
            .autoKey(IpsecTunnelAutoKeyArgs.builder()
                .ikeGateways(IpsecTunnelAutoKeyIkeGatewayArgs.builder()
                    .name(exampleIkeGateway.name())
                    .build())
                .ipsecCryptoProfile(exampleIpsecCryptoProfile.name())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleIkeGateway)
                .build());

        var siteAVpnSc = new ServiceConnection("siteAVpnSc", ServiceConnectionArgs.builder()
            .name("creating_a_service_connection_data")
            .region("us-west-1")
            .ipsecTunnel(exampleIpsecTunnel.name())
            .subnets(            
                "10.1.0.0/16",
                "172.16.0.0/24")
            .sourceNat(true)
            .build());

        //------------------------------------------------------
        // Data Soruce
        //------------------------------------------------------
        final var createdConnLookup = ScmFunctions.getServiceConnection(GetServiceConnectionArgs.builder()
            .id(siteAVpnSc.id())
            .build());

        ctx.export("createdServiceConnectionId", createdConnLookup.applyValue(_createdConnLookup -> _createdConnLookup.id()));
        ctx.export("createdServiceConnectionRegion", createdConnLookup.applyValue(_createdConnLookup -> _createdConnLookup.region()));
        ctx.export("createdServiceConnectionSubnets", createdConnLookup.applyValue(_createdConnLookup -> _createdConnLookup.subnets()));
    }
}

configuration:
  folderScope:
    type: string
    default: Service Connections
resources:
  ## 1. Define the IKE Crypto Profile (IKE Phase 1)
  # Note: The resource name is plural: "scm_ike_crypto_profile"
  example:
    type: scm:IkeCryptoProfile
    properties:
      name: example-ike-crypto_data
      folder: ${folderScope}
      hashes:
        - sha256
      dhGroups:
        - group14
      encryptions:
        - aes-256-cbc
  ## 2. Define the IPsec Crypto Profile (IKE Phase 2)
  # Note: The resource name is plural and nested blocks now use an equals sign (=).
  exampleIpsecCryptoProfile:
    type: scm:IpsecCryptoProfile
    name: example
    properties:
      name: panw-IPSec-Crypto_data
      folder: ${folderScope}
      esp:
        encryptions:
          - aes-256-gcm
        authentications:
          - sha256
      dhGroup: group14
      lifetime:
        hours: 8
  ## 3. Define the IKE Gateway
  # Note: The resource name is plural and nested blocks now use an equals sign (=).
  exampleIkeGateway:
    type: scm:IkeGateway
    name: example
    properties:
      name: example-gateway_data
      folder: ${folderScope}
      peerAddress:
        ip: 1.1.1.1
      authentication:
        preSharedKey:
          key: secret
      protocol:
        ikev1:
          ikeCryptoProfile: ${example.name}
  ## 4. Define the IPsec Tunnel
  # Note: Nested 'auto_key' block uses an equals sign (=).
  exampleIpsecTunnel:
    type: scm:IpsecTunnel
    name: example
    properties:
      name: example-tunnel_data
      folder: ${folderScope}
      tunnelInterface: tunnel
      antiReplay: true
      copyTos: false
      enableGreEncapsulation: false
      autoKey:
        ikeGateways:
          - name: ${exampleIkeGateway.name}
        ipsecCryptoProfile: ${exampleIpsecCryptoProfile.name}
    options:
      dependsOn:
        - ${exampleIkeGateway}
  siteAVpnSc:
    type: scm:ServiceConnection
    name: site_a_vpn_sc
    properties:
      name: creating_a_service_connection_data
      region: us-west-1
      ipsecTunnel: ${exampleIpsecTunnel.name}
      subnets:
        - 10.1.0.0/16
        - 172.16.0.0/24
      sourceNat: true
variables:
  #------------------------------------------------------
  # Data Soruce
  #------------------------------------------------------
  createdConnLookup:
    fn::invoke:
      function: scm:getServiceConnection
      arguments:
        id: ${siteAVpnSc.id}
outputs:
  createdServiceConnectionId: ${createdConnLookup.id}
  createdServiceConnectionRegion: ${createdConnLookup.region}
  createdServiceConnectionSubnets: ${createdConnLookup.subnets}

function getServiceConnection(args: GetServiceConnectionArgs, opts?: InvokeOptions): Promise<GetServiceConnectionResult>
function getServiceConnectionOutput(args: GetServiceConnectionOutputArgs, opts?: InvokeOptions): Output<GetServiceConnectionResult>

def get_service_connection(id: Optional[str] = None,
                           name: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetServiceConnectionResult
def get_service_connection_output(id: Optional[pulumi.Input[str]] = None,
                           name: Optional[pulumi.Input[str]] = None,
                           opts: Optional[InvokeOptions] = None) -> Output[GetServiceConnectionResult]

func LookupServiceConnection(ctx *Context, args *LookupServiceConnectionArgs, opts ...InvokeOption) (*LookupServiceConnectionResult, error)
func LookupServiceConnectionOutput(ctx *Context, args *LookupServiceConnectionOutputArgs, opts ...InvokeOption) LookupServiceConnectionResultOutput

public static class GetServiceConnection 
{
    public static Task<GetServiceConnectionResult> InvokeAsync(GetServiceConnectionArgs args, InvokeOptions? opts = null)
    public static Output<GetServiceConnectionResult> Invoke(GetServiceConnectionInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetServiceConnectionResult> getServiceConnection(GetServiceConnectionArgs args, InvokeOptions options)
public static Output<GetServiceConnectionResult> getServiceConnection(GetServiceConnectionArgs args, InvokeOptions options)

fn::invoke:
  function: scm:index/getServiceConnection:getServiceConnection
  arguments:
    # arguments dictionary