getReservedIpTypes

Linode v6.6.0, Sep 15 26

Viewing docs for Linode v6.6.0
published on Tuesday, Sep 15, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-linode

Viewing docs for Linode v6.6.0
published on Tuesday, Sep 15, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-linode

Example Usage

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

const all = linode.getReservedIpTypes({});
export const typeIds = all.then(all => all.types.map(__item => __item.id));

import pulumi
import pulumi_linode as linode

all = linode.get_reserved_ip_types()
pulumi.export("typeIds", [__item.id for __item in all.types])

package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v6/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
all, err := linode.GetReservedIpTypes(ctx, &linode.GetReservedIpTypesArgs{
}, nil);
if err != nil {
return err
}
ctx.Export("typeIds", pulumi.StringArray(%!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:3,11-26)))
return nil
})
}

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

return await Deployment.RunAsync(() => 
{
    var all = Linode.GetReservedIpTypes.Invoke();

    return new Dictionary<string, object?>
    {
        ["typeIds"] = all.Apply(getReservedIpTypesResult => getReservedIpTypesResult.Types).Select(__item => __item.Id).ToList(),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LinodeFunctions;
import com.pulumi.linode.inputs.GetReservedIpTypesArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 all = LinodeFunctions.getReservedIpTypes(GetReservedIpTypesArgs.builder()
            .build());

        ctx.export("typeIds", all.types().stream().map(element -> element.id()).collect(toList()));
    }
}

Example coming soon!

pulumi {
  required_providers {
    linode = {
      source = "pulumi/linode"
    }
  }
}

data "linode_getreservediptypes" "all" {
}

output "typeIds" {
  value = data.linode_getreservediptypes.all.types[*].id
}

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

const specific = linode.getReservedIpTypes({
    filters: [{
        name: "id",
        values: ["reserved-ip"],
    }],
});
export const label = specific.then(specific => specific.types?.[0]?.label);

import pulumi
import pulumi_linode as linode

specific = linode.get_reserved_ip_types(filters=[{
    "name": "id",
    "values": ["reserved-ip"],
}])
pulumi.export("label", specific.types[0].label)

package main

import (
	"github.com/pulumi/pulumi-linode/sdk/v6/go/linode"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		specific, err := linode.GetReservedIpTypes(ctx, &linode.GetReservedIpTypesArgs{
			Filters: []linode.GetReservedIpTypesFilter{
				{
					Name: "id",
					Values: []string{
						"reserved-ip",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("label", specific.Types[0].Label)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var specific = Linode.GetReservedIpTypes.Invoke(new()
    {
        Filters = new[]
        {
            new Linode.Inputs.GetReservedIpTypesFilterInputArgs
            {
                Name = "id",
                Values = new[]
                {
                    "reserved-ip",
                },
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["label"] = specific.Apply(getReservedIpTypesResult => getReservedIpTypesResult.Types[0]?.Label),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.linode.LinodeFunctions;
import com.pulumi.linode.inputs.GetReservedIpTypesArgs;
import com.pulumi.linode.inputs.GetReservedIpTypesFilterArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 specific = LinodeFunctions.getReservedIpTypes(GetReservedIpTypesArgs.builder()
            .filters(GetReservedIpTypesFilterArgs.builder()
                .name("id")
                .values("reserved-ip")
                .build())
            .build());

        ctx.export("label", specific.types()[0].label());
    }
}

variables:
  specific:
    fn::invoke:
      function: linode:getReservedIpTypes
      arguments:
        filters:
          - name: id
            values:
              - reserved-ip
outputs:
  label: ${specific.types[0].label}

pulumi {
  required_providers {
    linode = {
      source = "pulumi/linode"
    }
  }
}

data "linode_getreservediptypes" "specific" {
  filters {
    name   = "id"
    values = ["reserved-ip"]
  }
}

output "label" {
  value = data.linode_getreservediptypes.specific.types[0].label
}

Filterable Fields

label

Using getReservedIpTypes

Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

function getReservedIpTypes(args: GetReservedIpTypesArgs, opts?: InvokeOptions): Promise<GetReservedIpTypesResult>
function getReservedIpTypesOutput(args: GetReservedIpTypesOutputArgs, opts?: InvokeOutputOptions): Output<GetReservedIpTypesResult>

def get_reserved_ip_types(filters: Optional[Sequence[GetReservedIpTypesFilter]] = None,
                          order: Optional[str] = None,
                          order_by: Optional[str] = None,
                          opts: Optional[InvokeOptions] = None) -> GetReservedIpTypesResult
def get_reserved_ip_types_output(filters: pulumi.Input[Optional[Sequence[pulumi.Input[GetReservedIpTypesFilterArgs]]]] = None,
                          order: pulumi.Input[Optional[str]] = None,
                          order_by: pulumi.Input[Optional[str]] = None,
                          opts: Optional[InvokeOutputOptions] = None) -> Output[GetReservedIpTypesResult]

func GetReservedIpTypes(ctx *Context, args *GetReservedIpTypesArgs, opts ...InvokeOption) (*GetReservedIpTypesResult, error)
func GetReservedIpTypesOutput(ctx *Context, args *GetReservedIpTypesOutputArgs, opts ...InvokeOption) GetReservedIpTypesResultOutput

> Note: This function is named GetReservedIpTypes in the Go SDK.

public static class GetReservedIpTypes 
{
    public static Task<GetReservedIpTypesResult> InvokeAsync(GetReservedIpTypesArgs args, InvokeOptions? opts = null)
    public static Output<GetReservedIpTypesResult> Invoke(GetReservedIpTypesInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetReservedIpTypesResult> Invoke(GetReservedIpTypesInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetReservedIpTypesResult> getReservedIpTypes(GetReservedIpTypesArgs args, InvokeOptions options)
public static Output<GetReservedIpTypesResult> getReservedIpTypes(GetReservedIpTypesArgs args, InvokeOptions options)
public static Output<GetReservedIpTypesResult> getReservedIpTypes(GetReservedIpTypesArgs args, InvokeOutputOptions options)

fn::invoke:
  function: linode:index/getReservedIpTypes:getReservedIpTypes
  arguments:
    # arguments dictionary

data "linode_get_reserved_ip_types" "name" {
    # arguments
}

The following arguments are supported:

Filters List<GetReservedIpTypesFilter>
Order string: The order in which results should be returned. (asc, desc; default asc)
OrderBy string: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

Filters []GetReservedIpTypesFilter
Order string: The order in which results should be returned. (asc, desc; default asc)
OrderBy string: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

filters list(object)
order string: The order in which results should be returned. (asc, desc; default asc)
order_by string: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

filters List<GetReservedIpTypesFilter>
order String: The order in which results should be returned. (asc, desc; default asc)
orderBy String: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

filters GetReservedIpTypesFilter[]
order string: The order in which results should be returned. (asc, desc; default asc)
orderBy string: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

filters Sequence[GetReservedIpTypesFilter]
order str: The order in which results should be returned. (asc, desc; default asc)
order_by str: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.

filters List<Property Map>
order String: The order in which results should be returned. (asc, desc; default asc)
orderBy String: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.