ns1.Record

import * as pulumi from "@pulumi/pulumi";
import * as external from "@pulumi/external";
import * as ns1 from "@pulumi/ns1";
import * as std from "@pulumi/std";

const example = new ns1.Zone("example", {zone: "terraform.example.io"});
const ns1 = new ns1.DataSource("ns1", {
    name: "ns1_source",
    sourcetype: "nsone_v1",
});
const foo = new ns1.DataFeed("foo", {
    name: "foo_feed",
    sourceId: ns1.id,
    config: {
        label: "foo",
    },
});
const bar = new ns1.DataFeed("bar", {
    name: "bar_feed",
    sourceId: ns1.id,
    config: {
        label: "bar",
    },
});
const www = new ns1.Record("www", {
    zone: tld.zone,
    domain: `www.${tld.zone}`,
    type: "CNAME",
    ttl: 60,
    meta: {
        up: true,
    },
    regions: [
        {
            name: "east",
            meta: {
                georegion: "US-EAST",
            },
        },
        {
            name: "usa",
            meta: {
                country: "US",
            },
        },
    ],
    answers: [
        {
            answer: `sub1.${tld.zone}`,
            region: "east",
            meta: {
                up: pulumi.interpolate`{"feed":"${foo.id}"}`,
            },
        },
        {
            answer: `sub2.${tld.zone}`,
            meta: {
                up: pulumi.interpolate`{"feed":"${bar.id}"}`,
                connections: 3,
            },
        },
        {
            answer: `sub3.${tld.zone}`,
            meta: {
                pulsar: JSON.stringify([{
                    job_id: "abcdef",
                    bias: "*0.55",
                    a5m_cutoff: 0.9,
                }]),
                subdivisions: JSON.stringify({
                    BR: [
                        "SP",
                        "SC",
                    ],
                    DZ: [
                        "01",
                        "02",
                        "03",
                    ],
                }),
            },
        },
    ],
    filters: [{
        filter: "select_first_n",
        config: {
            N: 1,
        },
    }],
});
// Some other non-NS1 provider that returns a zone with a trailing dot and a domain with a leading dot.
const baz = new external.index.Source("baz", {
    zone: "terraform.example.io.",
    domain: ".www.terraform.example.io",
});
// Basic record showing how to clean a zone or domain field that comes from
// another non-NS1 resource. DNS names often end in '.' characters to signify
// the root of the DNS tree, but the NS1 provider does not support this.
//
// In other cases, a domain or zone may be passed in with a preceding dot ('.')
// character which would likewise lead the system to fail.
const external = new ns1.Record("external", {
    zone: std.replace({
        text: zone,
        search: "/(^\\.)|(\\.$)/",
        replace: "",
    }).then(invoke => invoke.result),
    domain: std.replace({
        text: domain,
        search: "/(^\\.)|(\\.$)/",
        replace: "",
    }).then(invoke => invoke.result),
    type: "CNAME",
});

import pulumi
import json
import pulumi_external as external
import pulumi_ns1 as ns1
import pulumi_std as std

example = ns1.Zone("example", zone="terraform.example.io")
ns1 = ns1.DataSource("ns1",
    name="ns1_source",
    sourcetype="nsone_v1")
foo = ns1.DataFeed("foo",
    name="foo_feed",
    source_id=ns1.id,
    config={
        "label": "foo",
    })
bar = ns1.DataFeed("bar",
    name="bar_feed",
    source_id=ns1.id,
    config={
        "label": "bar",
    })
www = ns1.Record("www",
    zone=tld["zone"],
    domain=f"www.{tld['zone']}",
    type="CNAME",
    ttl=60,
    meta={
        "up": True,
    },
    regions=[
        ns1.RecordRegionArgs(
            name="east",
            meta={
                "georegion": "US-EAST",
            },
        ),
        ns1.RecordRegionArgs(
            name="usa",
            meta={
                "country": "US",
            },
        ),
    ],
    answers=[
        ns1.RecordAnswerArgs(
            answer=f"sub1.{tld['zone']}",
            region="east",
            meta={
                "up": foo.id.apply(lambda id: f"{{\"feed\":\"{id}\"}}"),
            },
        ),
        ns1.RecordAnswerArgs(
            answer=f"sub2.{tld['zone']}",
            meta={
                "up": bar.id.apply(lambda id: f"{{\"feed\":\"{id}\"}}"),
                "connections": 3,
            },
        ),
        ns1.RecordAnswerArgs(
            answer=f"sub3.{tld['zone']}",
            meta={
                "pulsar": json.dumps([{
                    "job_id": "abcdef",
                    "bias": "*0.55",
                    "a5m_cutoff": 0.9,
                }]),
                "subdivisions": json.dumps({
                    "BR": [
                        "SP",
                        "SC",
                    ],
                    "DZ": [
                        "01",
                        "02",
                        "03",
                    ],
                }),
            },
        ),
    ],
    filters=[ns1.RecordFilterArgs(
        filter="select_first_n",
        config={
            "N": 1,
        },
    )])
# Some other non-NS1 provider that returns a zone with a trailing dot and a domain with a leading dot.
baz = external.index.Source("baz",
    zone=terraform.example.io.,
    domain=.www.terraform.example.io)
# Basic record showing how to clean a zone or domain field that comes from
# another non-NS1 resource. DNS names often end in '.' characters to signify
# the root of the DNS tree, but the NS1 provider does not support this.
#
# In other cases, a domain or zone may be passed in with a preceding dot ('.')
# character which would likewise lead the system to fail.
external = ns1.Record("external",
    zone=std.replace(text=zone,
        search="/(^\\.)|(\\.$)/",
        replace="").result,
    domain=std.replace(text=domain,
        search="/(^\\.)|(\\.$)/",
        replace="").result,
    type="CNAME")

package main

import (
	"encoding/json"
	"fmt"

	"github.com/pulumi/pulumi-external/sdk/v1/go/external"
	"github.com/pulumi/pulumi-ns1/sdk/v3/go/ns1"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ns1.NewZone(ctx, "example", &ns1.ZoneArgs{
			Zone: pulumi.String("terraform.example.io"),
		})
		if err != nil {
			return err
		}
		ns1, err := ns1.NewDataSource(ctx, "ns1", &ns1.DataSourceArgs{
			Name:       pulumi.String("ns1_source"),
			Sourcetype: pulumi.String("nsone_v1"),
		})
		if err != nil {
			return err
		}
		foo, err := ns1.NewDataFeed(ctx, "foo", &ns1.DataFeedArgs{
			Name:     pulumi.String("foo_feed"),
			SourceId: ns1.ID(),
			Config: pulumi.Map{
				"label": pulumi.Any("foo"),
			},
		})
		if err != nil {
			return err
		}
		bar, err := ns1.NewDataFeed(ctx, "bar", &ns1.DataFeedArgs{
			Name:     pulumi.String("bar_feed"),
			SourceId: ns1.ID(),
			Config: pulumi.Map{
				"label": pulumi.Any("bar"),
			},
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal([]map[string]interface{}{
			map[string]interface{}{
				"job_id":     "abcdef",
				"bias":       "*0.55",
				"a5m_cutoff": 0.9,
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"BR": []string{
				"SP",
				"SC",
			},
			"DZ": []string{
				"01",
				"02",
				"03",
			},
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		_, err = ns1.NewRecord(ctx, "www", &ns1.RecordArgs{
			Zone:   pulumi.Any(tld.Zone),
			Domain: pulumi.String(fmt.Sprintf("www.%v", tld.Zone)),
			Type:   pulumi.String("CNAME"),
			Ttl:    pulumi.Int(60),
			Meta: pulumi.Map{
				"up": pulumi.Any(true),
			},
			Regions: ns1.RecordRegionArray{
				&ns1.RecordRegionArgs{
					Name: pulumi.String("east"),
					Meta: pulumi.Map{
						"georegion": pulumi.Any("US-EAST"),
					},
				},
				&ns1.RecordRegionArgs{
					Name: pulumi.String("usa"),
					Meta: pulumi.Map{
						"country": pulumi.Any("US"),
					},
				},
			},
			Answers: ns1.RecordAnswerArray{
				&ns1.RecordAnswerArgs{
					Answer: pulumi.String(fmt.Sprintf("sub1.%v", tld.Zone)),
					Region: pulumi.String("east"),
					Meta: pulumi.Map{
						"up": foo.ID().ApplyT(func(id string) (string, error) {
							return fmt.Sprintf("{\"feed\":\"%v\"}", id), nil
						}).(pulumi.StringOutput),
					},
				},
				&ns1.RecordAnswerArgs{
					Answer: pulumi.String(fmt.Sprintf("sub2.%v", tld.Zone)),
					Meta: pulumi.Map{
						"up": bar.ID().ApplyT(func(id string) (string, error) {
							return fmt.Sprintf("{\"feed\":\"%v\"}", id), nil
						}).(pulumi.StringOutput),
						"connections": pulumi.Any(3),
					},
				},
				&ns1.RecordAnswerArgs{
					Answer: pulumi.String(fmt.Sprintf("sub3.%v", tld.Zone)),
					Meta: pulumi.Map{
						"pulsar":       pulumi.String(json0),
						"subdivisions": pulumi.String(json1),
					},
				},
			},
			Filters: ns1.RecordFilterArray{
				&ns1.RecordFilterArgs{
					Filter: pulumi.String("select_first_n"),
					Config: pulumi.Map{
						"N": pulumi.Any(1),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Some other non-NS1 provider that returns a zone with a trailing dot and a domain with a leading dot.
		_, err = index.NewSource(ctx, "baz", &index.SourceArgs{
			Zone:   "terraform.example.io.",
			Domain: ".www.terraform.example.io",
		})
		if err != nil {
			return err
		}
		invokeReplace, err := std.Replace(ctx, &std.ReplaceArgs{
			Text:    zone,
			Search:  "/(^\\.)|(\\.$)/",
			Replace: "",
		}, nil)
		if err != nil {
			return err
		}
		invokeReplace1, err := std.Replace(ctx, &std.ReplaceArgs{
			Text:    domain,
			Search:  "/(^\\.)|(\\.$)/",
			Replace: "",
		}, nil)
		if err != nil {
			return err
		}
		// Basic record showing how to clean a zone or domain field that comes from
		// another non-NS1 resource. DNS names often end in '.' characters to signify
		// the root of the DNS tree, but the NS1 provider does not support this.
		//
		// In other cases, a domain or zone may be passed in with a preceding dot ('.')
		// character which would likewise lead the system to fail.
		_, err = ns1.NewRecord(ctx, "external", &ns1.RecordArgs{
			Zone:   invokeReplace.Result,
			Domain: invokeReplace1.Result,
			Type:   pulumi.String("CNAME"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using External = Pulumi.External;
using Ns1 = Pulumi.Ns1;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var example = new Ns1.Zone("example", new()
    {
        ZoneName = "terraform.example.io",
    });

    var ns1 = new Ns1.DataSource("ns1", new()
    {
        Name = "ns1_source",
        Sourcetype = "nsone_v1",
    });

    var foo = new Ns1.DataFeed("foo", new()
    {
        Name = "foo_feed",
        SourceId = ns1.Id,
        Config = 
        {
            { "label", "foo" },
        },
    });

    var bar = new Ns1.DataFeed("bar", new()
    {
        Name = "bar_feed",
        SourceId = ns1.Id,
        Config = 
        {
            { "label", "bar" },
        },
    });

    var www = new Ns1.Record("www", new()
    {
        Zone = tld.Zone,
        Domain = $"www.{tld.Zone}",
        Type = "CNAME",
        Ttl = 60,
        Meta = 
        {
            { "up", true },
        },
        Regions = new[]
        {
            new Ns1.Inputs.RecordRegionArgs
            {
                Name = "east",
                Meta = 
                {
                    { "georegion", "US-EAST" },
                },
            },
            new Ns1.Inputs.RecordRegionArgs
            {
                Name = "usa",
                Meta = 
                {
                    { "country", "US" },
                },
            },
        },
        Answers = new[]
        {
            new Ns1.Inputs.RecordAnswerArgs
            {
                Answer = $"sub1.{tld.Zone}",
                Region = "east",
                Meta = 
                {
                    { "up", foo.Id.Apply(id => $"{{\"feed\":\"{id}\"}}") },
                },
            },
            new Ns1.Inputs.RecordAnswerArgs
            {
                Answer = $"sub2.{tld.Zone}",
                Meta = 
                {
                    { "up", bar.Id.Apply(id => $"{{\"feed\":\"{id}\"}}") },
                    { "connections", 3 },
                },
            },
            new Ns1.Inputs.RecordAnswerArgs
            {
                Answer = $"sub3.{tld.Zone}",
                Meta = 
                {
                    { "pulsar", JsonSerializer.Serialize(new[]
                    {
                        new Dictionary<string, object?>
                        {
                            ["job_id"] = "abcdef",
                            ["bias"] = "*0.55",
                            ["a5m_cutoff"] = 0.9,
                        },
                    }) },
                    { "subdivisions", JsonSerializer.Serialize(new Dictionary<string, object?>
                    {
                        ["BR"] = new[]
                        {
                            "SP",
                            "SC",
                        },
                        ["DZ"] = new[]
                        {
                            "01",
                            "02",
                            "03",
                        },
                    }) },
                },
            },
        },
        Filters = new[]
        {
            new Ns1.Inputs.RecordFilterArgs
            {
                Filter = "select_first_n",
                Config = 
                {
                    { "N", 1 },
                },
            },
        },
    });

    // Some other non-NS1 provider that returns a zone with a trailing dot and a domain with a leading dot.
    var baz = new External.Index.Source("baz", new()
    {
        Zone = "terraform.example.io.",
        Domain = ".www.terraform.example.io",
    });

    // Basic record showing how to clean a zone or domain field that comes from
    // another non-NS1 resource. DNS names often end in '.' characters to signify
    // the root of the DNS tree, but the NS1 provider does not support this.
    //
    // In other cases, a domain or zone may be passed in with a preceding dot ('.')
    // character which would likewise lead the system to fail.
    var external = new Ns1.Record("external", new()
    {
        Zone = Std.Replace.Invoke(new()
        {
            Text = zone,
            Search = "/(^\\.)|(\\.$)/",
            Replace = "",
        }).Apply(invoke => invoke.Result),
        Domain = Std.Replace.Invoke(new()
        {
            Text = domain,
            Search = "/(^\\.)|(\\.$)/",
            Replace = "",
        }).Apply(invoke => invoke.Result),
        Type = "CNAME",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.ns1.Zone;
import com.pulumi.ns1.ZoneArgs;
import com.pulumi.ns1.DataSource;
import com.pulumi.ns1.DataSourceArgs;
import com.pulumi.ns1.DataFeed;
import com.pulumi.ns1.DataFeedArgs;
import com.pulumi.ns1.Record;
import com.pulumi.ns1.RecordArgs;
import com.pulumi.ns1.inputs.RecordRegionArgs;
import com.pulumi.ns1.inputs.RecordAnswerArgs;
import com.pulumi.ns1.inputs.RecordFilterArgs;
import com.pulumi.external.source;
import com.pulumi.external.SourceArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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) {
        var example = new Zone("example", ZoneArgs.builder()
            .zone("terraform.example.io")
            .build());

        var ns1 = new DataSource("ns1", DataSourceArgs.builder()
            .name("ns1_source")
            .sourcetype("nsone_v1")
            .build());

        var foo = new DataFeed("foo", DataFeedArgs.builder()
            .name("foo_feed")
            .sourceId(ns1.id())
            .config(Map.of("label", "foo"))
            .build());

        var bar = new DataFeed("bar", DataFeedArgs.builder()
            .name("bar_feed")
            .sourceId(ns1.id())
            .config(Map.of("label", "bar"))
            .build());

        var www = new Record("www", RecordArgs.builder()
            .zone(tld.zone())
            .domain(String.format("www.%s", tld.zone()))
            .type("CNAME")
            .ttl(60)
            .meta(Map.of("up", true))
            .regions(            
                RecordRegionArgs.builder()
                    .name("east")
                    .meta(Map.of("georegion", "US-EAST"))
                    .build(),
                RecordRegionArgs.builder()
                    .name("usa")
                    .meta(Map.of("country", "US"))
                    .build())
            .answers(            
                RecordAnswerArgs.builder()
                    .answer(String.format("sub1.%s", tld.zone()))
                    .region("east")
                    .meta(Map.of("up", foo.id().applyValue(id -> String.format("{{\"feed\":\"%s\"}}", id))))
                    .build(),
                RecordAnswerArgs.builder()
                    .answer(String.format("sub2.%s", tld.zone()))
                    .meta(Map.ofEntries(
                        Map.entry("up", bar.id().applyValue(id -> String.format("{{\"feed\":\"%s\"}}", id))),
                        Map.entry("connections", 3)
                    ))
                    .build(),
                RecordAnswerArgs.builder()
                    .answer(String.format("sub3.%s", tld.zone()))
                    .meta(Map.ofEntries(
                        Map.entry("pulsar", serializeJson(
                            jsonArray(jsonObject(
                                jsonProperty("job_id", "abcdef"),
                                jsonProperty("bias", "*0.55"),
                                jsonProperty("a5m_cutoff", 0.9)
                            )))),
                        Map.entry("subdivisions", serializeJson(
                            jsonObject(
                                jsonProperty("BR", jsonArray(
                                    "SP", 
                                    "SC"
                                )),
                                jsonProperty("DZ", jsonArray(
                                    "01", 
                                    "02", 
                                    "03"
                                ))
                            )))
                    ))
                    .build())
            .filters(RecordFilterArgs.builder()
                .filter("select_first_n")
                .config(Map.of("N", 1))
                .build())
            .build());

        // Some other non-NS1 provider that returns a zone with a trailing dot and a domain with a leading dot.
        var baz = new Source("baz", SourceArgs.builder()
            .zone("terraform.example.io.")
            .domain(".www.terraform.example.io")
            .build());

        // Basic record showing how to clean a zone or domain field that comes from
        // another non-NS1 resource. DNS names often end in '.' characters to signify
        // the root of the DNS tree, but the NS1 provider does not support this.
        //
        // In other cases, a domain or zone may be passed in with a preceding dot ('.')
        // character which would likewise lead the system to fail.
        var external = new Record("external", RecordArgs.builder()
            .zone(StdFunctions.replace(ReplaceArgs.builder()
                .text(zone)
                .search("/(^\\.)|(\\.$)/")
                .replace("")
                .build()).result())
            .domain(StdFunctions.replace(ReplaceArgs.builder()
                .text(domain)
                .search("/(^\\.)|(\\.$)/")
                .replace("")
                .build()).result())
            .type("CNAME")
            .build());

    }
}

resources:
  example:
    type: ns1:Zone
    properties:
      zone: terraform.example.io
  ns1:
    type: ns1:DataSource
    properties:
      name: ns1_source
      sourcetype: nsone_v1
  foo:
    type: ns1:DataFeed
    properties:
      name: foo_feed
      sourceId: ${ns1.id}
      config:
        label: foo
  bar:
    type: ns1:DataFeed
    properties:
      name: bar_feed
      sourceId: ${ns1.id}
      config:
        label: bar
  www:
    type: ns1:Record
    properties:
      zone: ${tld.zone}
      domain: www.${tld.zone}
      type: CNAME
      ttl: 60
      meta:
        up: true
      regions:
        - name: east
          meta:
            georegion: US-EAST
        - name: usa
          meta:
            country: US
      answers:
        - answer: sub1.${tld.zone}
          region: east
          meta:
            up: '{"feed":"${foo.id}"}'
        - answer: sub2.${tld.zone}
          meta:
            up: '{"feed":"${bar.id}"}'
            connections: 3
        - answer: sub3.${tld.zone}
          meta:
            pulsar:
              fn::toJSON:
                - job_id: abcdef
                  bias: '*0.55'
                  a5m_cutoff: 0.9
            subdivisions:
              fn::toJSON:
                BR:
                  - SP
                  - SC
                DZ:
                  - '01'
                  - '02'
                  - '03'
      filters:
        - filter: select_first_n
          config:
            N: 1
  # Some other non-NS1 provider that returns a zone with a trailing dot and a domain with a leading dot.
  baz:
    type: external:source
    properties:
      zone: terraform.example.io.
      domain: .www.terraform.example.io
  # Basic record showing how to clean a zone or domain field that comes from
  # another non-NS1 resource. DNS names often end in '.' characters to signify
  # the root of the DNS tree, but the NS1 provider does not support this.
  #
  # In other cases, a domain or zone may be passed in with a preceding dot ('.')
  # character which would likewise lead the system to fail.
  external:
    type: ns1:Record
    properties:
      zone:
        fn::invoke:
          Function: std:replace
          Arguments:
            text: ${zone}
            search: /(^\.)|(\.$)/
            replace:
          Return: result
      domain:
        fn::invoke:
          Function: std:replace
          Arguments:
            text: ${domain}
            search: /(^\.)|(\.$)/
            replace:
          Return: result
      type: CNAME

var recordResource = new Ns1.Record("recordResource", new()
{
    Type = "string",
    Zone = "string",
    Domain = "string",
    OverrideTtl = false,
    Link = "string",
    Meta = 
    {
        { "string", "any" },
    },
    Answers = new[]
    {
        new Ns1.Inputs.RecordAnswerArgs
        {
            Answer = "string",
            Meta = 
            {
                { "string", "any" },
            },
            Region = "string",
        },
    },
    Regions = new[]
    {
        new Ns1.Inputs.RecordRegionArgs
        {
            Name = "string",
            Meta = 
            {
                { "string", "any" },
            },
        },
    },
    Tags = 
    {
        { "string", "string" },
    },
    Ttl = 0,
    Filters = new[]
    {
        new Ns1.Inputs.RecordFilterArgs
        {
            Filter = "string",
            Config = 
            {
                { "string", "any" },
            },
            Disabled = false,
        },
    },
    UseClientSubnet = false,
    BlockedTags = new[]
    {
        "string",
    },
});

example, err := ns1.NewRecord(ctx, "recordResource", &ns1.RecordArgs{
	Type:        pulumi.String("string"),
	Zone:        pulumi.String("string"),
	Domain:      pulumi.String("string"),
	OverrideTtl: pulumi.Bool(false),
	Link:        pulumi.String("string"),
	Meta: pulumi.Map{
		"string": pulumi.Any("any"),
	},
	Answers: ns1.RecordAnswerArray{
		&ns1.RecordAnswerArgs{
			Answer: pulumi.String("string"),
			Meta: pulumi.Map{
				"string": pulumi.Any("any"),
			},
			Region: pulumi.String("string"),
		},
	},
	Regions: ns1.RecordRegionArray{
		&ns1.RecordRegionArgs{
			Name: pulumi.String("string"),
			Meta: pulumi.Map{
				"string": pulumi.Any("any"),
			},
		},
	},
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Ttl: pulumi.Int(0),
	Filters: ns1.RecordFilterArray{
		&ns1.RecordFilterArgs{
			Filter: pulumi.String("string"),
			Config: pulumi.Map{
				"string": pulumi.Any("any"),
			},
			Disabled: pulumi.Bool(false),
		},
	},
	UseClientSubnet: pulumi.Bool(false),
	BlockedTags: pulumi.StringArray{
		pulumi.String("string"),
	},
})

var recordResource = new Record("recordResource", RecordArgs.builder()
    .type("string")
    .zone("string")
    .domain("string")
    .overrideTtl(false)
    .link("string")
    .meta(Map.of("string", "any"))
    .answers(RecordAnswerArgs.builder()
        .answer("string")
        .meta(Map.of("string", "any"))
        .region("string")
        .build())
    .regions(RecordRegionArgs.builder()
        .name("string")
        .meta(Map.of("string", "any"))
        .build())
    .tags(Map.of("string", "string"))
    .ttl(0)
    .filters(RecordFilterArgs.builder()
        .filter("string")
        .config(Map.of("string", "any"))
        .disabled(false)
        .build())
    .useClientSubnet(false)
    .blockedTags("string")
    .build());

record_resource = ns1.Record("recordResource",
    type="string",
    zone="string",
    domain="string",
    override_ttl=False,
    link="string",
    meta={
        "string": "any",
    },
    answers=[ns1.RecordAnswerArgs(
        answer="string",
        meta={
            "string": "any",
        },
        region="string",
    )],
    regions=[ns1.RecordRegionArgs(
        name="string",
        meta={
            "string": "any",
        },
    )],
    tags={
        "string": "string",
    },
    ttl=0,
    filters=[ns1.RecordFilterArgs(
        filter="string",
        config={
            "string": "any",
        },
        disabled=False,
    )],
    use_client_subnet=False,
    blocked_tags=["string"])

const recordResource = new ns1.Record("recordResource", {
    type: "string",
    zone: "string",
    domain: "string",
    overrideTtl: false,
    link: "string",
    meta: {
        string: "any",
    },
    answers: [{
        answer: "string",
        meta: {
            string: "any",
        },
        region: "string",
    }],
    regions: [{
        name: "string",
        meta: {
            string: "any",
        },
    }],
    tags: {
        string: "string",
    },
    ttl: 0,
    filters: [{
        filter: "string",
        config: {
            string: "any",
        },
        disabled: false,
    }],
    useClientSubnet: false,
    blockedTags: ["string"],
});

type: ns1:Record
properties:
    answers:
        - answer: string
          meta:
            string: any
          region: string
    blockedTags:
        - string
    domain: string
    filters:
        - config:
            string: any
          disabled: false
          filter: string
    link: string
    meta:
        string: any
    overrideTtl: false
    regions:
        - meta:
            string: any
          name: string
    tags:
        string: string
    ttl: 0
    type: string
    useClientSubnet: false
    zone: string