pulumi-extra-crds 1.0.0 → 1.0.14

package/README.md

@@ -0,0 +1,325 @@
+# crd2pulumi
+Generate typed CustomResources based on Kubernetes CustomResourceDefinitions.
+
+## Goals
+
+`crd2pulumi` is a CLI tool that generates typed CustomResources based on Kubernetes CustomResourceDefinition (CRDs). 
+CRDs allow you to extend the Kubernetes API by defining your own schemas for custom objects. While Pulumi lets you create
+ [CustomResources](https://www.pulumi.com/docs/reference/pkg/kubernetes/apiextensions/customresource/), there was previously 
+ no strong-typing for these objects since every schema was, well, custom. This can be a massive headache for popular CRDs 
+ such as [cert-manager](https://github.com/jetstack/cert-manager/tree/master/deploy/crds) or 
+ [istio](https://github.com/istio/istio/tree/0321da58ca86fc786fb03a68afd29d082477e4f2/manifests/charts/base/crds), which 
+ contain thousands of lines of complex YAML schemas. By generating typed versions of CustomResources, `crd2pulumi` makes 
+ filling out their arguments more convenient by allowing you to leverage existing IDE type checking and autocomplete features.
+
+## Building and Installation
+If you wish to use `crd2pulumi` without developing the tool itself, you can use one of the [binary releases](https://github.com/pulumi/crd2pulumi/releases) hosted on this repository. 
+
+### Homebrew
+`crd2pulumi` can be installed on Mac from the Pulumi Homebrew tap.
+```console
+brew install pulumi/tap/crd2pulumi
+```
+
+`crd2pulumi` uses Go modules to manage dependencies. If you want to develop `crd2pulumi` itself, you'll need to have 
+Go installed in order to build. Once you install this prerequisite, run the following to build the `crd2pulumi` binary 
+and install it into `$GOPATH/bin`:
+
+```bash
+$ go build -ldflags="-X github.com/pulumi/crd2pulumi/gen.Version=dev" -o $GOPATH/bin/crd2pulumi main.go
+```
+The `ldflags` argument is necessary to dynamically set the `crd2pulumi` version at build time. However, the version 
+itself can be anything, so you don't have to set it to `dev`.
+
+Go should then automatically handle pulling the dependencies for you. If `$GOPATH/bin` is not on your path, you may 
+want to move the `crd2pulumi` binary from `$GOPATH/bin` into a directory that is on your path.
+
+## Usage
+```bash
+crd2pulumi is a CLI tool that generates typed Kubernetes
+CustomResources to use in Pulumi programs, based on a
+CustomResourceDefinition YAML schema.
+
+Usage:
+  crd2pulumi [-dgnp] [--nodejsPath path] [--pythonPath path] [--dotnetPath path] [--goPath path] [--javaPath path] <crd1.yaml> [crd2.yaml ...] [flags]
+  crd2pulumi [command]
+
+Examples:
+crd2pulumi --nodejs crontabs.yaml
+crd2pulumi -dgnp crd-certificates.yaml crd-issuers.yaml crd-challenges.yaml
+crd2pulumi --pythonPath=crds/python/istio --nodejsPath=crds/nodejs/istio crd-all.gen.yaml crd-mixer.yaml crd-operator.yaml
+crd2pulumi --pythonPath=crds/python/gke https://raw.githubusercontent.com/GoogleCloudPlatform/gke-managed-certs/master/deploy/managedcertificates-crd.yaml
+
+Notice that by just setting a language-specific output path (--pythonPath, --nodejsPath, etc) the code will
+still get generated, so setting -p, -n, etc becomes unnecessary.
+
+
+Available Commands:
+  help        Help about any command
+  version     Print the version number of crd2pulumi
+
+Flags:
+  -d, --dotnet                       generate .NET
+      --dotnetName string            name of generated .NET package (default "crds")
+      --dotnetNamespace string       namespace of generated .NET package
+      --dotnetPath string            optional .NET output dir
+  -f, --force                        overwrite existing files
+  -g, --go                           generate Go
+      --goName string                name of generated Go package (default "crds")
+      --goPath string                optional Go output dir
+  -h, --help                         help for crd2pulumi
+  -j, --java                         generate Java
+      --javaBasePackage string       base package of generated Java package
+      --javaName string              name of generated Java package (default "crds")
+      --javaPath string              optional Java output dir
+  -n, --nodejs                       generate NodeJS
+      --nodejsName string            name of generated NodeJS package (default "crds")
+      --nodejsNamespace string       namespace of generated NodeJS package
+      --nodejsPath string            optional NodeJS output dir
+  -p, --python                       generate Python
+      --pythonName string            name of generated Python package (default "crds")
+      --pythonPackagePrefix string   prefix of generated Python package
+      --pythonPath string            optional Python output dir
+
+
+Use "crd2pulumi [command] --help" for more information about a command.
+```
+Setting only a language-specific flag will output the generated code in the default directory; so `-d` will output to 
+`crds/dotnet`, `-g` will output to `crds/go`, `-j` will output to `crds/java`, `-n` will output to `crds/nodejs`, and 
+`-p` will output to `crds/python`. You can also specify a language-specific path (`--pythonPath`, `--nodejsPath`, etc) 
+to control where the code will be outputted, in which case setting `-p`, `-n`, etc becomes unnecessary.
+
+## Examples
+Let's use the example CronTab CRD specified in `resourcedefinition.yaml` from the 
+[Kubernetes Documentation](https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/). 
+
+### TypeScript
+To generate a strongly-typed CronTab CustomResource in TypeScript, we can run this command:
+```bash
+$ crd2pulumi --nodejsPath ./crontabs resourcedefinition.yaml
+```
+Now let's import the generated code into a Pulumi program that provisions the CRD and creates an instance of it.
+```typescript
+import * as crontabs from "./crontabs"
+import * as pulumi from "@pulumi/pulumi"
+import * as k8s from "@pulumi/kubernetes";
+
+// Register the CronTab CRD.
+const cronTabDefinition = new k8s.yaml.ConfigFile("my-crontab-definition", { file: "resourcedefinition.yaml" });
+
+// Instantiate a CronTab resource.
+const myCronTab = new crontabs.stable.v1.CronTab("my-new-cron-object",
+{
+    metadata: {
+        name: "my-new-cron-object",
+    },
+    spec: {
+        cronSpec: "* * * * */5",
+        image: "my-awesome-cron-image",
+    }
+})
+
+```
+As you can see, the `CronTab` object is typed! For example, if you try to set
+`cronSpec` to a non-string or add an extra field, your IDE should immediately warn you.
+
+### Python
+```bash
+$ crd2pulumi --pythonPath ./crontabs resourcedefinition.yaml
+```
+```python
+import pulumi_kubernetes as k8s
+import crontabs.pulumi_crds as crontabs
+
+
+# Register the CronTab CRD.
+crontab_definition = k8s.yaml.ConfigFile("my-crontab-definition", file="resourcedefinition.yaml")
+
+# Instantiate a CronTab resource.
+crontab_instance = crontabs.stable.v1.CronTab(
+    "my-new-cron-object",
+    metadata=k8s.meta.v1.ObjectMetaArgs(
+        name="my-new-cron-object"
+    ),
+    spec=crontabs.stable.v1.CronTabSpecArgs(
+        cron_spec="* * * */5",
+        image="my-awesome-cron-image",
+    )
+)
+
+```
+
+### Go
+```bash
+$ crd2pulumi --goPath ./crontabs resourcedefinition.yaml
+```
+Now we can access the `NewCronTab()` constructor. Create a `main.go` file with the following code. In this example, 
+the Pulumi project's module is named `crds-go-final`, so the import path is `crds-go-final/crontabs/stable/v1`. Make 
+sure to swap this out with your own module's name.
+```go
+package main
+
+import (
+	crontabs_v1 "crds-go-final/crontabs/stable/v1"
+
+	meta_v1 "github.com/pulumi/pulumi-kubernetes/sdk/v2/go/kubernetes/meta/v1"
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+func main() {
+	pulumi.Run(func(ctx *pulumi.Context) error {
+    // Register the CronTab CRD.
+    _, err := yaml.NewConfigFile(ctx, "my-crontab-definition",
+      &yaml.ConfigFileArgs{
+        File: "resourcedefinition.yaml",
+      },
+    )
+    if err != nil {
+      return err
+    }
+
+		// Instantiate a CronTab resource.
+		_, err := crontabs_v1.NewCronTab(ctx, "cronTabInstance", &crontabs_v1.CronTabArgs{
+			Metadata: &meta_v1.ObjectMetaArgs{
+				Name: pulumi.String("my-new-cron-object"),
+			},
+			Spec: crontabs_v1.CronTabSpecArgs{
+				CronSpec: pulumi.String("* * * * */5"),
+				Image:    pulumi.String("my-awesome-cron-image"),
+				Replicas: pulumi.IntPtr(3),
+			},
+		})
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+}
+
+```
+
+### C\#
+```bash
+$ crd2pulumi --dotnetPath ./crontabs resourcedefinition.yaml
+```
+```csharp
+using Pulumi;
+using Pulumi.Kubernetes.Yaml;
+using Pulumi.Kubernetes.Types.Inputs.Meta.V1;
+
+class MyStack : Stack
+{
+    public MyStack()
+    {
+    // Register a CronTab CRD.
+    var cronTabDefinition = new Pulumi.Kubernetes.Yaml.ConfigFile("my-crontab-definition",
+        new ConfigFileArgs{
+            File = "resourcedefinition.yaml"
+        }
+    );
+
+    // Instantiate a CronTab resource.
+    var cronTabInstance = new Pulumi.Crds.Stable.V1.CronTab("cronTabInstance",
+        new Pulumi.Kubernetes.Types.Inputs.Stable.V1.CronTabArgs{
+            Metadata = new ObjectMetaArgs{
+                Name = "my-new-cron-object"
+            },
+            Spec = new Pulumi.Kubernetes.Types.Inputs.Stable.V1.CronTabSpecArgs{
+                CronSpec = "* * * * */5",
+                Image = "my-awesome-cron-image"
+            }
+        });    
+    }
+}
+
+```
+
+> If you get an `Duplicate 'global::System.Runtime.Versioning.TargetFrameworkAttribute' attribute` error when trying to run `pulumi up`, then try deleting the `crontabs/bin` and `crontabs/obj` folders.
+
+### Java
+```bash
+$ crd2pulumi --javaPath ./crontabs resourcedefinition.yaml
+```
+```java
+package com.example;
+
+import com.pulumi.Pulumi;
+
+public class MyStack {
+
+    public static void main(String[] args) {
+        Pulumi.run(ctx -> {
+            // Register a CronTab CRD (Coming Soon - see https://www.pulumi.com/registry/packages/kubernetes/api-docs/yaml/configfile/)
+
+            // Instantiate a CronTab resource.
+            var cronTabInstance = new com.pulumi.crds.stable.v1.CronTab("cronTabInstance",
+                    com.pulumi.crds.stable.v1.CronTabArgs.builder()
+                            .metadata(com.pulumi.kubernetes.meta.v1.inputs.ObjectMetaArgs.builder()
+                                    .name("my-new-cron-object")
+                                    .build())
+                            .spec(com.pulumi.kubernetes.stable.v1.inputs.CronTabSpecArgs.builder()
+                                    .cronSpec("* * * * */5")
+                                    .image("my-awesome-cron-image")
+                                    .build())
+                            .build());
+        });
+    }
+}
+
+```
+
+Now let's run the program and perform the update.
+```bash
+$ pulumi up
+Previewing update (dev):
+  Type                                                      Name                Plan
+  pulumi:pulumi:Stack                                       examples-dev
+ +   ├─ kubernetes:stable.example.com:CronTab                   my-new-cron-object  create
+ +   └─ kubernetes:apiextensions.k8s.io:CustomResourceDefinition  my-crontab-definition  create
+Resources:
+  + 2 to create
+  1 unchanged
+Do you want to perform this update? yes
+Updating (dev):
+  Type                                                      Name                Status
+  pulumi:pulumi:Stack                                       examples-dev
+ +   ├─ kubernetes:stable.example.com:CronTab                   my-new-cron-object  created
+ +   └─ kubernetes:apiextensions.k8s.io:CustomResourceDefinition  my-crontab-definition  created
+Outputs:
+  urn: "urn:pulumi:dev::examples::kubernetes:stable.example.com/v1:CronTab::my-new-cron-object"
+Resources:
+  + 2 created
+  1 unchanged
+Duration: 17s
+Permalink: https://app.pulumi.com/albert-zhong/examples/dev/updates/4
+```
+It looks like both the CronTab definition and instance were both created! Finally, let's verify that they were created
+by manually viewing the raw YAML data:
+```bash
+$ kubectl get ct -o yaml
+```
+```yaml
+- apiVersion: stable.example.com/v1
+  kind: CronTab
+  metadata:
+  annotations:
+    kubectl.kubernetes.io/last-applied-configuration: |
+      {"apiVersion":"stable.example.com/v1","kind":"CronTab","metadata":{"labels":{"app.kubernetes.io/managed-by":"pulumi"},"name":"my-new-cron-object"},"spec":{"cronSpec":"* * * * */5","image":"my-awesome-cron-image"}}
+  creationTimestamp: "2020-08-10T09:50:38Z"
+  generation: 1
+  labels:
+    app.kubernetes.io/managed-by: pulumi
+  name: my-new-cron-object
+  namespace: default
+  resourceVersion: "1658962"
+  selfLink: /apis/stable.example.com/v1/namespaces/default/crontabs/my-new-cron-object
+  uid: 5e2c56a2-7332-49cf-b0fc-211a0892c3d5
+  spec:
+  cronSpec: '* * * * */5'
+  image: my-awesome-cron-image
+kind: List
+metadata:
+  resourceVersion: ""
+  selfLink: ""
+```

package/generated/crds/README.md

@@ -0,0 +1,14 @@
+The Kubernetes provider package offers support for all Kubernetes resources and their properties.
+Resources are exposed as types from modules based on Kubernetes API groups such as 'apps', 'core',
+'rbac', and 'storage', among many others. Additionally, support for deploying Helm charts ('helm')
+and YAML files ('yaml') is available in this package. Using this package allows you to
+programmatically declare instances of any Kubernetes resources and any supported resource version
+using infrastructure as code, which Pulumi then uses to drive the Kubernetes API.
+
+If this is your first time using this package, these two resources may be helpful:
+
+* [Kubernetes Getting Started Guide](https://www.pulumi.com/docs/quickstart/kubernetes/): Get up and running quickly.
+* [Kubernetes Pulumi Setup Documentation](https://www.pulumi.com/docs/quickstart/kubernetes/configure/): How to configure Pulumi
+    for use with your Kubernetes cluster.
+
+Use the navigation below to see detailed documentation for each of the supported Kubernetes resources.

package/generated/crds/acme/index.d.ts

@@ -0,0 +1,2 @@
+import * as v1 from "./v1";
+export { v1, };

package/generated/crds/acme/index.js

@@ -0,0 +1,8 @@
+"use strict";
+// *** WARNING: this file was generated by crd2pulumi. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v1 = void 0;
+// Export sub-modules:
+const v1 = require("./v1");
+exports.v1 = v1;

package/generated/crds/acme/index.ts

@@ -0,0 +1,11 @@
+// *** WARNING: this file was generated by crd2pulumi. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import * as utilities from "../utilities";
+
+// Export sub-modules:
+import * as v1 from "./v1";
+
+export {
+    v1,
+};

package/generated/crds/acme/v1/challenge.d.ts

@@ -0,0 +1,64 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as inputs from "../../types/input";
+import * as outputs from "../../types/output";
+/**
+ * Challenge is a type to represent a Challenge request with an ACME server
+ */
+export declare class Challenge extends pulumi.CustomResource {
+    /**
+     * Get an existing Challenge resource's state with the given name, ID, and optional extra
+     * properties used to qualify the lookup.
+     *
+     * @param name The _unique_ name of the resulting resource.
+     * @param id The _unique_ provider ID of the resource to lookup.
+     * @param opts Optional settings to control the behavior of the CustomResource.
+     */
+    static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): Challenge;
+    /** @internal */
+    static readonly __pulumiType = "kubernetes:acme.cert-manager.io/v1:Challenge";
+    /**
+     * Returns true if the given object is an instance of Challenge.  This is designed to work even
+     * when multiple copies of the Pulumi SDK have been loaded into the same process.
+     */
+    static isInstance(obj: any): obj is Challenge;
+    /**
+     * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
+     */
+    readonly apiVersion: pulumi.Output<"acme.cert-manager.io/v1">;
+    /**
+     * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
+     */
+    readonly kind: pulumi.Output<"Challenge">;
+    /**
+     * Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
+     */
+    readonly metadata: pulumi.Output<outputs.meta.v1.ObjectMeta>;
+    readonly spec: pulumi.Output<outputs.acme.v1.ChallengeSpec>;
+    readonly status: pulumi.Output<outputs.acme.v1.ChallengeStatus>;
+    /**
+     * Create a Challenge resource with the given unique name, arguments, and options.
+     *
+     * @param name The _unique_ name of the resource.
+     * @param args The arguments to use to populate this resource's properties.
+     * @param opts A bag of options that control this resource's behavior.
+     */
+    constructor(name: string, args?: ChallengeArgs, opts?: pulumi.CustomResourceOptions);
+}
+/**
+ * The set of arguments for constructing a Challenge resource.
+ */
+export interface ChallengeArgs {
+    /**
+     * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
+     */
+    apiVersion?: pulumi.Input<"acme.cert-manager.io/v1">;
+    /**
+     * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
+     */
+    kind?: pulumi.Input<"Challenge">;
+    /**
+     * Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
+     */
+    metadata?: pulumi.Input<inputs.meta.v1.ObjectMeta>;
+    spec?: pulumi.Input<inputs.acme.v1.ChallengeSpec>;
+}

package/generated/crds/acme/v1/challenge.js

@@ -0,0 +1,63 @@
+"use strict";
+// *** WARNING: this file was generated by crd2pulumi. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Challenge = void 0;
+const pulumi = require("@pulumi/pulumi");
+const utilities = require("../../utilities");
+/**
+ * Challenge is a type to represent a Challenge request with an ACME server
+ */
+class Challenge extends pulumi.CustomResource {
+    /**
+     * Get an existing Challenge resource's state with the given name, ID, and optional extra
+     * properties used to qualify the lookup.
+     *
+     * @param name The _unique_ name of the resulting resource.
+     * @param id The _unique_ provider ID of the resource to lookup.
+     * @param opts Optional settings to control the behavior of the CustomResource.
+     */
+    static get(name, id, opts) {
+        return new Challenge(name, undefined, { ...opts, id: id });
+    }
+    /**
+     * Returns true if the given object is an instance of Challenge.  This is designed to work even
+     * when multiple copies of the Pulumi SDK have been loaded into the same process.
+     */
+    static isInstance(obj) {
+        if (obj === undefined || obj === null) {
+            return false;
+        }
+        return obj['__pulumiType'] === Challenge.__pulumiType;
+    }
+    /**
+     * Create a Challenge resource with the given unique name, arguments, and options.
+     *
+     * @param name The _unique_ name of the resource.
+     * @param args The arguments to use to populate this resource's properties.
+     * @param opts A bag of options that control this resource's behavior.
+     */
+    constructor(name, args, opts) {
+        let resourceInputs = {};
+        opts = opts || {};
+        if (!opts.id) {
+            resourceInputs["apiVersion"] = "acme.cert-manager.io/v1";
+            resourceInputs["kind"] = "Challenge";
+            resourceInputs["metadata"] = args ? args.metadata : undefined;
+            resourceInputs["spec"] = args ? args.spec : undefined;
+            resourceInputs["status"] = undefined /*out*/;
+        }
+        else {
+            resourceInputs["apiVersion"] = undefined /*out*/;
+            resourceInputs["kind"] = undefined /*out*/;
+            resourceInputs["metadata"] = undefined /*out*/;
+            resourceInputs["spec"] = undefined /*out*/;
+            resourceInputs["status"] = undefined /*out*/;
+        }
+        opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts);
+        super(Challenge.__pulumiType, name, resourceInputs, opts);
+    }
+}
+exports.Challenge = Challenge;
+/** @internal */
+Challenge.__pulumiType = 'kubernetes:acme.cert-manager.io/v1:Challenge';

package/generated/crds/acme/v1/challenge.ts

@@ -0,0 +1,99 @@
+// *** WARNING: this file was generated by crd2pulumi. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import * as pulumi from "@pulumi/pulumi";
+import * as inputs from "../../types/input";
+import * as outputs from "../../types/output";
+import * as utilities from "../../utilities";
+
+/**
+ * Challenge is a type to represent a Challenge request with an ACME server
+ */
+export class Challenge extends pulumi.CustomResource {
+    /**
+     * Get an existing Challenge resource's state with the given name, ID, and optional extra
+     * properties used to qualify the lookup.
+     *
+     * @param name The _unique_ name of the resulting resource.
+     * @param id The _unique_ provider ID of the resource to lookup.
+     * @param opts Optional settings to control the behavior of the CustomResource.
+     */
+    public static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): Challenge {
+        return new Challenge(name, undefined as any, { ...opts, id: id });
+    }
+
+    /** @internal */
+    public static readonly __pulumiType = 'kubernetes:acme.cert-manager.io/v1:Challenge';
+
+    /**
+     * Returns true if the given object is an instance of Challenge.  This is designed to work even
+     * when multiple copies of the Pulumi SDK have been loaded into the same process.
+     */
+    public static isInstance(obj: any): obj is Challenge {
+        if (obj === undefined || obj === null) {
+            return false;
+        }
+        return obj['__pulumiType'] === Challenge.__pulumiType;
+    }
+
+    /**
+     * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
+     */
+    public readonly apiVersion!: pulumi.Output<"acme.cert-manager.io/v1">;
+    /**
+     * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
+     */
+    public readonly kind!: pulumi.Output<"Challenge">;
+    /**
+     * Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
+     */
+    public readonly metadata!: pulumi.Output<outputs.meta.v1.ObjectMeta>;
+    public readonly spec!: pulumi.Output<outputs.acme.v1.ChallengeSpec>;
+    public /*out*/ readonly status!: pulumi.Output<outputs.acme.v1.ChallengeStatus>;
+
+    /**
+     * Create a Challenge resource with the given unique name, arguments, and options.
+     *
+     * @param name The _unique_ name of the resource.
+     * @param args The arguments to use to populate this resource's properties.
+     * @param opts A bag of options that control this resource's behavior.
+     */
+    constructor(name: string, args?: ChallengeArgs, opts?: pulumi.CustomResourceOptions) {
+        let resourceInputs: pulumi.Inputs = {};
+        opts = opts || {};
+        if (!opts.id) {
+            resourceInputs["apiVersion"] = "acme.cert-manager.io/v1";
+            resourceInputs["kind"] = "Challenge";
+            resourceInputs["metadata"] = args ? args.metadata : undefined;
+            resourceInputs["spec"] = args ? args.spec : undefined;
+            resourceInputs["status"] = undefined /*out*/;
+        } else {
+            resourceInputs["apiVersion"] = undefined /*out*/;
+            resourceInputs["kind"] = undefined /*out*/;
+            resourceInputs["metadata"] = undefined /*out*/;
+            resourceInputs["spec"] = undefined /*out*/;
+            resourceInputs["status"] = undefined /*out*/;
+        }
+        opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts);
+        super(Challenge.__pulumiType, name, resourceInputs, opts);
+    }
+}
+
+/**
+ * The set of arguments for constructing a Challenge resource.
+ */
+export interface ChallengeArgs {
+    /**
+     * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
+     */
+    apiVersion?: pulumi.Input<"acme.cert-manager.io/v1">;
+    /**
+     * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
+     */
+    kind?: pulumi.Input<"Challenge">;
+    /**
+     * Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
+     */
+    metadata?: pulumi.Input<inputs.meta.v1.ObjectMeta>;
+    spec?: pulumi.Input<inputs.acme.v1.ChallengeSpec>;
+}

package/generated/crds/acme/v1/challengeList.d.ts

@@ -0,0 +1,69 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as inputs from "../../types/input";
+import * as outputs from "../../types/output";
+/**
+ * ChallengeList is a list of Challenge
+ */
+export declare class ChallengeList extends pulumi.CustomResource {
+    /**
+     * Get an existing ChallengeList resource's state with the given name, ID, and optional extra
+     * properties used to qualify the lookup.
+     *
+     * @param name The _unique_ name of the resulting resource.
+     * @param id The _unique_ provider ID of the resource to lookup.
+     * @param opts Optional settings to control the behavior of the CustomResource.
+     */
+    static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): ChallengeList;
+    /** @internal */
+    static readonly __pulumiType = "kubernetes:acme.cert-manager.io/v1:ChallengeList";
+    /**
+     * Returns true if the given object is an instance of ChallengeList.  This is designed to work even
+     * when multiple copies of the Pulumi SDK have been loaded into the same process.
+     */
+    static isInstance(obj: any): obj is ChallengeList;
+    /**
+     * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
+     */
+    readonly apiVersion: pulumi.Output<"acme.cert-manager.io/v1">;
+    /**
+     * List of challenges. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md
+     */
+    readonly items: pulumi.Output<outputs.acme.v1.Challenge[]>;
+    /**
+     * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
+     */
+    readonly kind: pulumi.Output<"ChallengeList">;
+    /**
+     * Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
+     */
+    readonly metadata: pulumi.Output<outputs.meta.v1.ListMeta>;
+    /**
+     * Create a ChallengeList resource with the given unique name, arguments, and options.
+     *
+     * @param name The _unique_ name of the resource.
+     * @param args The arguments to use to populate this resource's properties.
+     * @param opts A bag of options that control this resource's behavior.
+     */
+    constructor(name: string, args?: ChallengeListArgs, opts?: pulumi.CustomResourceOptions);
+}
+/**
+ * The set of arguments for constructing a ChallengeList resource.
+ */
+export interface ChallengeListArgs {
+    /**
+     * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
+     */
+    apiVersion?: pulumi.Input<"acme.cert-manager.io/v1">;
+    /**
+     * List of challenges. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md
+     */
+    items: pulumi.Input<pulumi.Input<inputs.acme.v1.Challenge>[]>;
+    /**
+     * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
+     */
+    kind?: pulumi.Input<"ChallengeList">;
+    /**
+     * Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
+     */
+    metadata?: pulumi.Input<inputs.meta.v1.ListMeta>;
+}