Schema

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const test = new aws.schemas.Registry("test", {name: "my_own_registry"});
const testSchema = new aws.schemas.Schema("test", {
    name: "my_schema",
    registryName: test.name,
    type: "OpenApi3",
    description: "The schema definition for my event",
    content: JSON.stringify({
        openapi: "3.0.0",
        info: {
            version: "1.0.0",
            title: "Event",
        },
        paths: {},
        components: {
            schemas: {
                Event: {
                    type: "object",
                    properties: {
                        name: {
                            type: "string",
                        },
                    },
                },
            },
        },
    }),
});

import pulumi
import json
import pulumi_aws as aws
test = aws.schemas.Registry("test", name="my_own_registry")
test_schema = aws.schemas.Schema("test",
    name="my_schema",
    registry_name=test.name,
    type="OpenApi3",
    description="The schema definition for my event",
    content=json.dumps({
        "openapi": "3.0.0",
        "info": {
            "version": "1.0.0",
            "title": "Event",
        },
        "paths": {},
        "components": {
            "schemas": {
                "Event": {
                    "type": "object",
                    "properties": {
                        "name": {
                            "type": "string",
                        },
                    },
                },
            },
        },
    }))

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var test = new Aws.Schemas.Registry("test", new()
    {
        Name = "my_own_registry",
    });
    var testSchema = new Aws.Schemas.Schema("test", new()
    {
        Name = "my_schema",
        RegistryName = test.Name,
        Type = "OpenApi3",
        Description = "The schema definition for my event",
        Content = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["openapi"] = "3.0.0",
            ["info"] = new Dictionary<string, object?>
            {
                ["version"] = "1.0.0",
                ["title"] = "Event",
            },
            ["paths"] = new Dictionary<string, object?>
            {
            },
            ["components"] = new Dictionary<string, object?>
            {
                ["schemas"] = new Dictionary<string, object?>
                {
                    ["Event"] = new Dictionary<string, object?>
                    {
                        ["type"] = "object",
                        ["properties"] = new Dictionary<string, object?>
                        {
                            ["name"] = new Dictionary<string, object?>
                            {
                                ["type"] = "string",
                            },
                        },
                    },
                },
            },
        }),
    });
});

package main
import (
	"encoding/json"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/schemas"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := schemas.NewRegistry(ctx, "test", &schemas.RegistryArgs{
			Name: pulumi.String("my_own_registry"),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"openapi": "3.0.0",
			"info": map[string]interface{}{
				"version": "1.0.0",
				"title":   "Event",
			},
			"paths": map[string]interface{}{},
			"components": map[string]interface{}{
				"schemas": map[string]interface{}{
					"Event": map[string]interface{}{
						"type": "object",
						"properties": map[string]interface{}{
							"name": map[string]interface{}{
								"type": "string",
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = schemas.NewSchema(ctx, "test", &schemas.SchemaArgs{
			Name:         pulumi.String("my_schema"),
			RegistryName: test.Name,
			Type:         pulumi.String("OpenApi3"),
			Description:  pulumi.String("The schema definition for my event"),
			Content:      pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.schemas.Registry;
import com.pulumi.aws.schemas.RegistryArgs;
import com.pulumi.aws.schemas.Schema;
import com.pulumi.aws.schemas.SchemaArgs;
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 test = new Registry("test", RegistryArgs.builder()
            .name("my_own_registry")
            .build());
        var testSchema = new Schema("testSchema", SchemaArgs.builder()
            .name("my_schema")
            .registryName(test.name())
            .type("OpenApi3")
            .description("The schema definition for my event")
            .content(serializeJson(
                jsonObject(
                    jsonProperty("openapi", "3.0.0"),
                    jsonProperty("info", jsonObject(
                        jsonProperty("version", "1.0.0"),
                        jsonProperty("title", "Event")
                    )),
                    jsonProperty("paths", jsonObject(
                    )),
                    jsonProperty("components", jsonObject(
                        jsonProperty("schemas", jsonObject(
                            jsonProperty("Event", jsonObject(
                                jsonProperty("type", "object"),
                                jsonProperty("properties", jsonObject(
                                    jsonProperty("name", jsonObject(
                                        jsonProperty("type", "string")
                                    ))
                                ))
                            ))
                        ))
                    ))
                )))
            .build());
    }
}

resources:
  test:
    type: aws:schemas:Registry
    properties:
      name: my_own_registry
  testSchema:
    type: aws:schemas:Schema
    name: test
    properties:
      name: my_schema
      registryName: ${test.name}
      type: OpenApi3
      description: The schema definition for my event
      content:
        fn::toJSON:
          openapi: 3.0.0
          info:
            version: 1.0.0
            title: Event
          paths: {}
          components:
            schemas:
              Event:
                type: object
                properties:
                  name:
                    type: string

$ pulumi import aws:schemas/schema:Schema test name/registry