{
  "name": "cockroach",
  "displayName": "CockroachDB",
  "version": "0.9.4",
  "description": "A Pulumi package to create and managed Cockroach DB resources in Pulumi programs.",
  "keywords": [
    "pulumi",
    "cockroach",
    "pulumiverse"
  ],
  "homepage": "https://www.cockroachlabs.com/",
  "license": "Apache-2.0",
  "attribution": "This Pulumi package is based on the [`cockroach` Terraform Provider](https://github.com/cockroachdb/terraform-provider-cockroach).",
  "repository": "https://github.com/pulumiverse/pulumi-cockroach",
  "logoUrl": "https://raw.githubusercontent.com/pulumiverse/pulumi-cockroach/main/assets/logo.png",
  "pluginDownloadURL": "github://api.github.com/pulumiverse",
  "publisher": "pulumiverse",
  "meta": {
    "moduleFormat": "(.*)(?:/[^/]*)"
  },
  "language": {
    "csharp": {
      "packageReferences": {
        "Pulumi": "3.*"
      },
      "namespaces": {
        "cockroach": "Cockroach"
      },
      "compatibility": "tfbridge20",
      "rootNamespace": "Pulumiverse",
      "respectSchemaVersion": true
    },
    "go": {
      "importBasePath": "github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach",
      "generateResourceContainerTypes": true,
      "generateExtraInputTypes": true,
      "respectSchemaVersion": true
    },
    "nodejs": {
      "packageName": "@pulumiverse/cockroach",
      "packageDescription": "A Pulumi package to create and managed Cockroach DB resources in Pulumi programs.",
      "readme": "> This provider is a derived work of the [Terraform Provider](https://github.com/cockroachdb/terraform-provider-cockroach)\n> distributed under [MPL 2.0](https://www.mozilla.org/en-US/MPL/2.0/). If you encounter a bug or missing feature,\n> first check the [`pulumi-cockroach` repo](https://github.com/pulumiverse/pulumi-cockroach/issues); however, if that doesn't turn up anything,\n> please consult the source [`terraform-provider-cockroach` repo](https://github.com/cockroachdb/terraform-provider-cockroach/issues).",
      "dependencies": {
        "@pulumi/pulumi": "^3.0.0"
      },
      "devDependencies": {
        "@types/node": "^10.0.0"
      },
      "compatibility": "tfbridge20",
      "disableUnionOutputTypes": true,
      "respectSchemaVersion": true
    },
    "python": {
      "packageName": "pulumiverse_cockroach",
      "requires": {
        "pulumi": ">=3.0.0,<4.0.0"
      },
      "readme": "> This provider is a derived work of the [Terraform Provider](https://github.com/cockroachdb/terraform-provider-cockroach)\n> distributed under [MPL 2.0](https://www.mozilla.org/en-US/MPL/2.0/). If you encounter a bug or missing feature,\n> first check the [`pulumi-cockroach` repo](https://github.com/pulumiverse/pulumi-cockroach/issues); however, if that doesn't turn up anything,\n> please consult the source [`terraform-provider-cockroach` repo](https://github.com/cockroachdb/terraform-provider-cockroach/issues).",
      "compatibility": "tfbridge20",
      "respectSchemaVersion": true,
      "pyproject": {
        "enabled": true
      }
    }
  },
  "config": {
    "variables": {
      "apijwt": {
        "type": "string",
        "description": "The JWT from a JWT Issuer configured for the CockroachDB Cloud Organization. In this case, the vanity name of the\norganization is required and can be provided using the `COCKROACH_VANITY_NAME` environment variable. If the JWT is\nmapped to multiple identities, the identity to impersonate should be provided using the `COCKROACH_USERNAME` environment\nvariable, and should contain either a user email address or a service account ID.\n",
        "secret": true
      },
      "apikey": {
        "type": "string",
        "description": "The API key to access CockroachDB Cloud. If this field is provided, it is used and `apijwt` is ignored.\n",
        "secret": true
      }
    }
  },
  "types": {
    "cockroach:index/ClusterBackupConfig:ClusterBackupConfig": {
      "properties": {
        "enabled": {
          "type": "boolean",
          "description": "Indicates whether backups are enabled. If set to false, no backups will be created.\n"
        },
        "frequencyMinutes": {
          "type": "integer",
          "description": "The frequency of backups in minutes.  Valid values are [5, 10, 15, 30, 60, 240, 1440]\n"
        },
        "retentionDays": {
          "type": "integer",
          "description": "The number of days to retain backups for.  Valid values are [2, 7, 30, 90, 365]. Can only be set once, further changes require opening a support ticket. See Updating backup retention for more information.\n"
        }
      },
      "type": "object",
      "language": {
        "nodejs": {
          "requiredOutputs": [
            "enabled",
            "frequencyMinutes",
            "retentionDays"
          ]
        }
      }
    },
    "cockroach:index/ClusterDedicated:ClusterDedicated": {
      "properties": {
        "cidrRange": {
          "type": "string",
          "description": "The IPv4 range in CIDR format that will be used by the cluster. This is supported only on GCP, and must have a subnet mask no larger than /19. Defaults to \"172.28.0.0/14\". This cannot be changed after cluster creation.\n"
        },
        "diskIops": {
          "type": "integer",
          "description": "Number of disk I/O operations per second that are permitted on each node in the cluster. Omitting this attribute will result in the cloud provider-specific default.\n"
        },
        "machineType": {
          "type": "string",
          "description": "Machine type identifier within the given cloud provider, e.g., m6.xlarge, n2-standard-4. This attribute requires a feature flag to be enabled. It is recommended to leave this empty and use `num_virtual_cpus` to control the machine type.\n"
        },
        "memoryGib": {
          "type": "number",
          "description": "Memory per node in GiB.\n"
        },
        "numVirtualCpus": {
          "type": "integer",
          "description": "Number of virtual CPUs per node in the cluster.\n"
        },
        "privateNetworkVisibility": {
          "type": "boolean",
          "description": "Set to true to assign private IP addresses to nodes. Required for CMEK and other advanced networking features. Clusters created with this flag will have advanced security features enabled.  This cannot be changed after cluster creation and incurs additional charges.  See [Create an Advanced Cluster](https://www.cockroachlabs.com/docs/cockroachcloud/create-an-advanced-cluster.html#step-6-configure-advanced-security-features) and [Pricing](https://www.cockroachlabs.com/pricing/) for more information.\n"
        },
        "storageGib": {
          "type": "integer",
          "description": "Storage amount per node in GiB.\n"
        }
      },
      "type": "object",
      "language": {
        "nodejs": {
          "requiredOutputs": [
            "cidrRange",
            "diskIops",
            "machineType",
            "memoryGib",
            "numVirtualCpus",
            "privateNetworkVisibility",
            "storageGib"
          ]
        }
      }
    },
    "cockroach:index/ClusterRegion:ClusterRegion": {
      "properties": {
        "internalDns": {
          "type": "string",
          "description": "Internal DNS name of the cluster within the cloud provider's network. Used to connect to the cluster with PrivateLink or VPC peering.\n"
        },
        "name": {
          "type": "string",
          "description": "Name of the region. Should match the region code used by the cluster's cloud provider.\n"
        },
        "nodeCount": {
          "type": "integer",
          "description": "Number of nodes in the region. Valid for Advanced clusters only.\n"
        },
        "primary": {
          "type": "boolean",
          "description": "Set to true to mark this region as the primary for a serverless cluster. Exactly one region must be primary. Dedicated clusters expect to have no primary region.\n"
        },
        "sqlDns": {
          "type": "string",
          "description": "DNS name of the cluster's SQL interface. Used to connect to the cluster with IP allowlisting.\n"
        },
        "uiDns": {
          "type": "string",
          "description": "DNS name used when connecting to the DB Console for the cluster.\n"
        }
      },
      "type": "object",
      "required": [
        "name"
      ],
      "language": {
        "nodejs": {
          "requiredOutputs": [
            "internalDns",
            "name",
            "nodeCount",
            "primary",
            "sqlDns",
            "uiDns"
          ]
        }
      }
    },
    "cockroach:index/ClusterServerless:ClusterServerless": {
      "properties": {
        "routingId": {
          "type": "string",
          "description": "Cluster identifier in a connection string.\n"
        },
        "spendLimit": {
          "type": "integer",
          "description": "Spend limit in US cents.\n",
          "deprecationMessage": "The `spend_limit` attribute is deprecated and will be removed in a future release of the provider. Configure 'usage_limits' instead."
        },
        "upgradeType": {
          "type": "string",
          "description": "Dictates the behavior of CockroachDB major version upgrades. Manual upgrades are not supported on CockroachDB Basic. Manual or automatic upgrades are supported on CockroachDB Standard. If you omit the field, it defaults to `AUTOMATIC`. Allowed values are:\n  * MANUAL\n  * AUTOMATIC\n"
        },
        "usageLimits": {
          "$ref": "#/types/cockroach:index%2FClusterServerlessUsageLimits:ClusterServerlessUsageLimits"
        }
      },
      "type": "object",
      "language": {
        "nodejs": {
          "requiredOutputs": [
            "routingId",
            "upgradeType"
          ]
        }
      }
    },
    "cockroach:index/ClusterServerlessUsageLimits:ClusterServerlessUsageLimits": {
      "properties": {
        "provisionedVirtualCpus": {
          "type": "integer",
          "description": "Maximum number of vCPUs that the cluster can use.\n"
        },
        "requestUnitLimit": {
          "type": "integer",
          "description": "Maximum number of Request Units that the cluster can consume during the month.\n"
        },
        "storageMibLimit": {
          "type": "integer",
          "description": "Maximum amount of storage (in MiB) that the cluster can have at any time during the month.\n"
        }
      },
      "type": "object"
    },
    "cockroach:index/CmekAdditionalRegion:CmekAdditionalRegion": {
      "properties": {
        "internalDns": {
          "type": "string",
          "description": "Internal DNS name of the cluster within the cloud provider's network. Used to connect to the cluster with PrivateLink or VPC peering.\n"
        },
        "name": {
          "type": "string",
          "description": "Name of the region. Should match the region code used by the cluster's cloud provider.\n"
        },
        "nodeCount": {
          "type": "integer",
          "description": "Number of nodes in the region. Valid for Advanced clusters only.\n"
        },
        "primary": {
          "type": "boolean",
          "description": "Set to true to mark this region as the primary for a serverless cluster. Exactly one region must be primary. Dedicated clusters expect to have no primary region.\n"
        },
        "sqlDns": {
          "type": "string",
          "description": "DNS name of the cluster's SQL interface. Used to connect to the cluster with IP allowlisting.\n"
        },
        "uiDns": {
          "type": "string",
          "description": "DNS name used when connecting to the DB Console for the cluster.\n"
        }
      },
      "type": "object",
      "required": [
        "name"
      ],
      "language": {
        "nodejs": {
          "requiredOutputs": [
            "internalDns",
            "name",
            "nodeCount",
            "primary",
            "sqlDns",
            "uiDns"
          ]
        }
      }
    },
    "cockroach:index/CmekRegion:CmekRegion": {
      "properties": {
        "key": {
          "$ref": "#/types/cockroach:index%2FCmekRegionKey:CmekRegionKey"
        },
        "region": {
          "type": "string",
          "description": "Cloud provider region code.\n"
        },
        "status": {
          "type": "string",
          "description": "Describes the status of the current encryption key within the region.\n"
        }
      },
      "type": "object",
      "required": [
        "key",
        "region"
      ],
      "language": {
        "nodejs": {
          "requiredOutputs": [
            "key",
            "region",
            "status"
          ]
        }
      }
    },
    "cockroach:index/CmekRegionKey:CmekRegionKey": {
      "properties": {
        "authPrincipal": {
          "type": "string",
          "description": "Principal to authenticate as in order to access the key.\n"
        },
        "createdAt": {
          "type": "string",
          "description": "Indicates when the key was created.\n"
        },
        "status": {
          "type": "string",
          "description": "Current status of this key.\n"
        },
        "type": {
          "type": "string",
          "description": "Type of encryption key. Current allowed values are:\n  * AWS_KMS\n  * GCP_CLOUD_KMS\n  * NULL_KMS\n"
        },
        "updatedAt": {
          "type": "string",
          "description": "Indicates when the key was last updated.\n"
        },
        "uri": {
          "type": "string",
          "description": "Provider-specific URI pointing to the encryption key.\n"
        },
        "userMessage": {
          "type": "string",
          "description": "Elaborates on the key's status and hints at how to fix issues that may have occurred during asynchronous key operations.\n"
        }
      },
      "type": "object",
      "required": [
        "authPrincipal",
        "type",
        "uri"
      ],
      "language": {
        "nodejs": {
          "requiredOutputs": [
            "authPrincipal",
            "createdAt",
            "status",
            "type",
            "updatedAt",
            "uri",
            "userMessage"
          ]
        }
      }
    },
    "cockroach:index/JwtIssuerIdentityMap:JwtIssuerIdentityMap": {
      "properties": {
        "ccIdentity": {
          "type": "string",
          "description": "Specifies how to map the fetched token identity to an identity in CockroachDB Cloud. In case of a regular expression for token_identity, this must contain a \\1 placeholder for the matched content. Note that you will need to escape the backslash in the string as in the example usage (\\\\1).\n"
        },
        "tokenIdentity": {
          "type": "string",
          "description": "Specifies how to fetch external identity from the token claim. A regular expression must start with a forward slash. The regular expression must be in RE2 compatible syntax. For further details, please see https://github.com/google/re2/wiki/Syntax.\n"
        }
      },
      "type": "object",
      "required": [
        "ccIdentity",
        "tokenIdentity"
      ]
    },
    "cockroach:index/LogExportConfigGroup:LogExportConfigGroup": {
      "properties": {
        "channels": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "A list of CockroachDB log channels to include in this group.\n"
        },
        "logName": {
          "type": "string",
          "description": "The name of the group, reflected in the log sink.\n"
        },
        "minLevel": {
          "type": "string",
          "description": "The minimum log level to filter to this log group.\n"
        },
        "redact": {
          "type": "boolean",
          "description": "Governs whether this log group should aggregate redacted logs if unset.\n"
        }
      },
      "type": "object",
      "required": [
        "channels",
        "logName"
      ]
    },
    "cockroach:index/PrivateEndpointServicesService:PrivateEndpointServicesService": {
      "properties": {
        "availabilityZoneIds": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Availability Zone IDs of the private endpoint service. It is recommended, for cost optimization purposes, to create the private endpoint spanning these same availability zones. For more information, see data transfer cost information for your cloud provider.\n"
        },
        "aws": {
          "$ref": "#/types/cockroach:index%2FPrivateEndpointServicesServiceAws:PrivateEndpointServicesServiceAws",
          "deprecationMessage": "nested aws fields have been moved one level up. These fields will be removed in a future version"
        },
        "cloudProvider": {
          "type": "string",
          "description": "Cloud provider associated with this service.\n"
        },
        "endpointServiceId": {
          "type": "string",
          "description": "Server side ID of the private endpoint connection.\n"
        },
        "name": {
          "type": "string",
          "description": "Name of the endpoint service.\n"
        },
        "regionName": {
          "type": "string",
          "description": "Cloud provider region code associated with this service.\n"
        },
        "status": {
          "type": "string",
          "description": "Operation status of the service.\n"
        }
      },
      "type": "object",
      "language": {
        "nodejs": {
          "requiredOutputs": [
            "availabilityZoneIds",
            "aws",
            "cloudProvider",
            "endpointServiceId",
            "name",
            "regionName",
            "status"
          ]
        }
      }
    },
    "cockroach:index/PrivateEndpointServicesServiceAws:PrivateEndpointServicesServiceAws": {
      "properties": {
        "availabilityZoneIds": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "AZ IDs users should create their VPCs in to minimize their cost.\n"
        },
        "serviceId": {
          "type": "string",
          "description": "Server side ID of the PrivateLink connection.\n"
        },
        "serviceName": {
          "type": "string",
          "description": "AWS service name used to create endpoints.\n"
        }
      },
      "type": "object",
      "language": {
        "nodejs": {
          "requiredOutputs": [
            "availabilityZoneIds",
            "serviceId",
            "serviceName"
          ]
        }
      }
    },
    "cockroach:index/PrivateEndpointServicesServicesMap:PrivateEndpointServicesServicesMap": {
      "properties": {
        "availabilityZoneIds": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Availability Zone IDs of the private endpoint service. It is recommended, for cost optimization purposes, to create the private endpoint spanning these same availability zones. For more information, see data transfer cost information for your cloud provider.\n"
        },
        "aws": {
          "$ref": "#/types/cockroach:index%2FPrivateEndpointServicesServicesMapAws:PrivateEndpointServicesServicesMapAws",
          "deprecationMessage": "nested aws fields have been moved one level up. These fields will be removed in a future version"
        },
        "cloudProvider": {
          "type": "string",
          "description": "Cloud provider associated with this service.\n"
        },
        "endpointServiceId": {
          "type": "string",
          "description": "Server side ID of the private endpoint connection.\n"
        },
        "name": {
          "type": "string",
          "description": "Name of the endpoint service.\n"
        },
        "regionName": {
          "type": "string",
          "description": "Cloud provider region code associated with this service.\n"
        },
        "status": {
          "type": "string",
          "description": "Operation status of the service.\n"
        }
      },
      "type": "object",
      "language": {
        "nodejs": {
          "requiredOutputs": [
            "availabilityZoneIds",
            "aws",
            "cloudProvider",
            "endpointServiceId",
            "name",
            "regionName",
            "status"
          ]
        }
      }
    },
    "cockroach:index/PrivateEndpointServicesServicesMapAws:PrivateEndpointServicesServicesMapAws": {
      "properties": {
        "availabilityZoneIds": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "AZ IDs users should create their VPCs in to minimize their cost.\n"
        },
        "serviceId": {
          "type": "string",
          "description": "Server side ID of the PrivateLink connection.\n"
        },
        "serviceName": {
          "type": "string",
          "description": "AWS service name used to create endpoints.\n"
        }
      },
      "type": "object",
      "language": {
        "nodejs": {
          "requiredOutputs": [
            "availabilityZoneIds",
            "serviceId",
            "serviceName"
          ]
        }
      }
    },
    "cockroach:index/UserRoleGrantRole:UserRoleGrantRole": {
      "properties": {
        "resourceId": {
          "type": "string",
          "description": "ID of the resource. Required if the resource_type is 'FOLDER' or 'CLUSTER'. It should be omitted otherwise.\n"
        },
        "resourceType": {
          "type": "string",
          "description": "Type of resource. Allowed values are:\n  * ORGANIZATION\n  * CLUSTER\n  * FOLDER\n"
        },
        "roleName": {
          "type": "string",
          "description": "Name of the role to grant. Allowed values are:\n  * BILLING_COORDINATOR\n  * ORG_ADMIN\n  * ORG_MEMBER\n  * CLUSTER_ADMIN\n  * CLUSTER_OPERATOR_WRITER\n  * CLUSTER_DEVELOPER\n  * CLUSTER_CREATOR\n  * FOLDER_ADMIN\n  * FOLDER_MOVER\n"
        }
      },
      "type": "object",
      "required": [
        "resourceType",
        "roleName"
      ]
    },
    "cockroach:index/UserRoleGrantsRole:UserRoleGrantsRole": {
      "properties": {
        "resourceId": {
          "type": "string",
          "description": "ID of the resource. Required if the resource_type is 'FOLDER' or 'CLUSTER'. It should be omitted otherwise.\n"
        },
        "resourceType": {
          "type": "string",
          "description": "Type of resource. Allowed values are: \n  * ORGANIZATION\n  * CLUSTER\n  * FOLDER\n"
        },
        "roleName": {
          "type": "string",
          "description": "Name of the role to grant. Allowed values are:\n  * BILLING_COORDINATOR\n  * ORG_ADMIN\n  * ORG_MEMBER\n  * CLUSTER_ADMIN\n  * CLUSTER_OPERATOR_WRITER\n  * CLUSTER_DEVELOPER\n  * CLUSTER_CREATOR\n  * FOLDER_ADMIN\n  * FOLDER_MOVER\n"
        }
      },
      "type": "object",
      "required": [
        "resourceType",
        "roleName"
      ]
    },
    "cockroach:index/getCockroachClusterBackupConfig:getCockroachClusterBackupConfig": {
      "properties": {
        "enabled": {
          "type": "boolean",
          "description": "Indicates whether backups are enabled.\n"
        },
        "frequencyMinutes": {
          "type": "integer",
          "description": "The frequency of backups in minutes.\n"
        },
        "retentionDays": {
          "type": "integer",
          "description": "The number of days to retain backups for.\n"
        }
      },
      "type": "object",
      "required": [
        "enabled",
        "frequencyMinutes",
        "retentionDays"
      ],
      "language": {
        "nodejs": {
          "requiredInputs": []
        }
      }
    },
    "cockroach:index/getCockroachClusterDedicated:getCockroachClusterDedicated": {
      "properties": {
        "cidrRange": {
          "type": "string",
          "description": "The IPv4 range in CIDR format that is in use by the cluster. It is only set on GCP clusters and is otherwise empty.\n"
        },
        "diskIops": {
          "type": "integer",
          "description": "Number of disk I/O operations per second that are permitted on each node in the cluster. Zero indicates the cloud provider-specific default.\n"
        },
        "machineType": {
          "type": "string",
          "description": "Machine type identifier within the given cloud provider, ex. m6.xlarge, n2-standard-4.\n"
        },
        "memoryGib": {
          "type": "number",
          "description": "Memory per node in GiB.\n"
        },
        "numVirtualCpus": {
          "type": "integer",
          "description": "Number of virtual CPUs per node in the cluster.\n"
        },
        "privateNetworkVisibility": {
          "type": "boolean",
          "description": "Indicates whether private IP addresses are assigned to nodes. Required for CMEK and other advanced networking features.\n"
        },
        "storageGib": {
          "type": "integer",
          "description": "Storage amount per node in GiB.\n"
        }
      },
      "type": "object",
      "required": [
        "cidrRange",
        "diskIops",
        "machineType",
        "memoryGib",
        "numVirtualCpus",
        "privateNetworkVisibility",
        "storageGib"
      ],
      "language": {
        "nodejs": {
          "requiredInputs": []
        }
      }
    },
    "cockroach:index/getCockroachClusterRegion:getCockroachClusterRegion": {
      "properties": {
        "internalDns": {
          "type": "string",
          "description": "Internal DNS name of the cluster within the cloud provider's network. Used to connect to the cluster with PrivateLink or VPC peering.\n"
        },
        "name": {
          "type": "string",
          "description": "Region code used by the cluster's cloud provider.\n"
        },
        "nodeCount": {
          "type": "integer",
          "description": "Number of nodes in the region. Will always be 0 for serverless clusters.\n"
        },
        "primary": {
          "type": "boolean",
          "description": "Denotes whether this is the primary region in a serverless cluster. Dedicated clusters don't have a primary region.\n"
        },
        "sqlDns": {
          "type": "string",
          "description": "DNS name of the cluster's SQL interface. Used to connect to the cluster with IP allowlisting.\n"
        },
        "uiDns": {
          "type": "string",
          "description": "DNS name used when connecting to the DB Console for the cluster.\n"
        }
      },
      "type": "object",
      "required": [
        "internalDns",
        "name",
        "nodeCount",
        "primary",
        "sqlDns",
        "uiDns"
      ],
      "language": {
        "nodejs": {
          "requiredInputs": []
        }
      }
    },
    "cockroach:index/getCockroachClusterServerless:getCockroachClusterServerless": {
      "properties": {
        "routingId": {
          "type": "string",
          "description": "Cluster identifier in a connection string.\n"
        },
        "spendLimit": {
          "type": "integer",
          "description": "Spend limit in US cents.\n",
          "deprecationMessage": "The `spend_limit` attribute is deprecated and will be removed in a future release of the provider. Configure 'usage_limits' instead."
        },
        "upgradeType": {
          "type": "string",
          "description": "Dictates the behavior of CockroachDB major version upgrades.\n"
        },
        "usageLimits": {
          "$ref": "#/types/cockroach:index%2FgetCockroachClusterServerlessUsageLimits:getCockroachClusterServerlessUsageLimits"
        }
      },
      "type": "object",
      "required": [
        "routingId",
        "spendLimit",
        "upgradeType",
        "usageLimits"
      ],
      "language": {
        "nodejs": {
          "requiredInputs": []
        }
      }
    },
    "cockroach:index/getCockroachClusterServerlessUsageLimits:getCockroachClusterServerlessUsageLimits": {
      "properties": {
        "provisionedVirtualCpus": {
          "type": "integer",
          "description": "Maximum number of vCPUs that the cluster can use.\n"
        },
        "requestUnitLimit": {
          "type": "integer",
          "description": "Maximum number of Request Units that the cluster can consume during the month.\n"
        },
        "storageMibLimit": {
          "type": "integer",
          "description": "Maximum amount of storage (in MiB) that the cluster can have at any time during the month.\n"
        }
      },
      "type": "object",
      "required": [
        "provisionedVirtualCpus",
        "requestUnitLimit",
        "storageMibLimit"
      ],
      "language": {
        "nodejs": {
          "requiredInputs": []
        }
      }
    },
    "cockroach:index/getConnectionStringConnectionParams:getConnectionStringConnectionParams": {
      "properties": {
        "database": {
          "type": "string",
          "description": "Database value to use in a connection URL.\n"
        },
        "host": {
          "type": "string",
          "description": "Host value to use in a connection URL.\n"
        },
        "password": {
          "type": "string",
          "description": "Password value to use in a connection URL.\n",
          "secret": true
        },
        "port": {
          "type": "string",
          "description": "Port value to use in a connection URL.\n"
        },
        "username": {
          "type": "string",
          "description": "Username value to use in a connection URL.\n"
        }
      },
      "type": "object",
      "required": [
        "database",
        "host",
        "password",
        "port",
        "username"
      ],
      "language": {
        "nodejs": {
          "requiredInputs": []
        }
      }
    }
  },
  "provider": {
    "description": "The provider type for the cockroach package. By default, resources use package-wide configuration\nsettings, however an explicit `Provider` instance may be created and passed during resource\nconstruction to achieve fine-grained programmatic control over provider settings. See the\n[documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information.\n",
    "properties": {
      "apijwt": {
        "type": "string",
        "description": "The JWT from a JWT Issuer configured for the CockroachDB Cloud Organization. In this case, the vanity name of the\norganization is required and can be provided using the `COCKROACH_VANITY_NAME` environment variable. If the JWT is\nmapped to multiple identities, the identity to impersonate should be provided using the `COCKROACH_USERNAME` environment\nvariable, and should contain either a user email address or a service account ID.\n",
        "secret": true
      },
      "apikey": {
        "type": "string",
        "description": "The API key to access CockroachDB Cloud. If this field is provided, it is used and `apijwt` is ignored.\n",
        "secret": true
      }
    },
    "type": "object",
    "inputProperties": {
      "apijwt": {
        "type": "string",
        "description": "The JWT from a JWT Issuer configured for the CockroachDB Cloud Organization. In this case, the vanity name of the\norganization is required and can be provided using the `COCKROACH_VANITY_NAME` environment variable. If the JWT is\nmapped to multiple identities, the identity to impersonate should be provided using the `COCKROACH_USERNAME` environment\nvariable, and should contain either a user email address or a service account ID.\n",
        "secret": true
      },
      "apikey": {
        "type": "string",
        "description": "The API key to access CockroachDB Cloud. If this field is provided, it is used and `apijwt` is ignored.\n",
        "secret": true
      }
    }
  },
  "resources": {
    "cockroach:index/allowList:AllowList": {
      "description": "List of IP ranges allowed to access the cluster.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst vpn = new cockroach.AllowList(\"vpn\", {\n    name: \"vpn\",\n    cidrIp: \"123.123.1.1\",\n    cidrMask: 32,\n    ui: true,\n    sql: true,\n    clusterId: staging.id,\n});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nvpn = cockroach.AllowList(\"vpn\",\n    name=\"vpn\",\n    cidr_ip=\"123.123.1.1\",\n    cidr_mask=32,\n    ui=True,\n    sql=True,\n    cluster_id=staging[\"id\"])\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var vpn = new Cockroach.AllowList(\"vpn\", new()\n    {\n        Name = \"vpn\",\n        CidrIp = \"123.123.1.1\",\n        CidrMask = 32,\n        Ui = true,\n        Sql = true,\n        ClusterId = staging.Id,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\t_, err := cockroach.NewAllowList(ctx, \"vpn\", &cockroach.AllowListArgs{\n\t\t\tName:      pulumi.String(\"vpn\"),\n\t\t\tCidrIp:    pulumi.String(\"123.123.1.1\"),\n\t\t\tCidrMask:  pulumi.Int(32),\n\t\t\tUi:        pulumi.Bool(true),\n\t\t\tSql:       pulumi.Bool(true),\n\t\t\tClusterId: pulumi.Any(staging.Id),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.AllowList;\nimport com.pulumi.cockroach.AllowListArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        var vpn = new AllowList(\"vpn\", AllowListArgs.builder()\n            .name(\"vpn\")\n            .cidrIp(\"123.123.1.1\")\n            .cidrMask(32)\n            .ui(true)\n            .sql(true)\n            .clusterId(staging.id())\n            .build());\n\n    }\n}\n```\n```yaml\nresources:\n  vpn:\n    type: cockroach:AllowList\n    properties:\n      name: vpn\n      cidrIp: 123.123.1.1\n      cidrMask: 32\n      ui: true\n      sql: true\n      clusterId: ${staging.id}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>:<cidr ip>/<cidr mask>\n\n```sh\n$ pulumi import cockroach:index/allowList:AllowList home_office 1f69fdd2-600a-4cfc-a9ba-16995df0d77d:123.123.1.1/32\n```\n\n",
      "properties": {
        "cidrIp": {
          "type": "string",
          "description": "IP address component of the [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation) range for this entry.\n"
        },
        "cidrMask": {
          "type": "integer",
          "description": "The [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation) notation prefix length. A number ranging from 0 to 32 indicating the size of the network. Use 32 to allow a single IP address.\n"
        },
        "clusterId": {
          "type": "string"
        },
        "name": {
          "type": "string",
          "description": "Name of this allowlist entry. If left unset, it will inherit a server-side default.\n"
        },
        "sql": {
          "type": "boolean",
          "description": "Set to 'true' to allow SQL connections from this CIDR range.\n"
        },
        "ui": {
          "type": "boolean",
          "description": "Set to 'true' to allow access to the management console from this CIDR range.\n"
        }
      },
      "type": "object",
      "required": [
        "cidrIp",
        "cidrMask",
        "clusterId",
        "name",
        "sql",
        "ui"
      ],
      "inputProperties": {
        "cidrIp": {
          "type": "string",
          "description": "IP address component of the [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation) range for this entry.\n"
        },
        "cidrMask": {
          "type": "integer",
          "description": "The [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation) notation prefix length. A number ranging from 0 to 32 indicating the size of the network. Use 32 to allow a single IP address.\n"
        },
        "clusterId": {
          "type": "string"
        },
        "name": {
          "type": "string",
          "description": "Name of this allowlist entry. If left unset, it will inherit a server-side default.\n"
        },
        "sql": {
          "type": "boolean",
          "description": "Set to 'true' to allow SQL connections from this CIDR range.\n"
        },
        "ui": {
          "type": "boolean",
          "description": "Set to 'true' to allow access to the management console from this CIDR range.\n"
        }
      },
      "requiredInputs": [
        "cidrIp",
        "cidrMask",
        "clusterId",
        "sql",
        "ui"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering AllowList resources.\n",
        "properties": {
          "cidrIp": {
            "type": "string",
            "description": "IP address component of the [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation) range for this entry.\n"
          },
          "cidrMask": {
            "type": "integer",
            "description": "The [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation) notation prefix length. A number ranging from 0 to 32 indicating the size of the network. Use 32 to allow a single IP address.\n"
          },
          "clusterId": {
            "type": "string"
          },
          "name": {
            "type": "string",
            "description": "Name of this allowlist entry. If left unset, it will inherit a server-side default.\n"
          },
          "sql": {
            "type": "boolean",
            "description": "Set to 'true' to allow SQL connections from this CIDR range.\n"
          },
          "ui": {
            "type": "boolean",
            "description": "Set to 'true' to allow access to the management console from this CIDR range.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/apiKey:ApiKey": {
      "description": "## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst example = new cockroach.ApiKey(\"example\", {\n    name: \"An example api key\",\n    serviceAccountId: exampleSa.id,\n});\nexport const exampleSecret = example.secret;\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nexample = cockroach.ApiKey(\"example\",\n    name=\"An example api key\",\n    service_account_id=example_sa[\"id\"])\npulumi.export(\"exampleSecret\", example.secret)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var example = new Cockroach.ApiKey(\"example\", new()\n    {\n        Name = \"An example api key\",\n        ServiceAccountId = exampleSa.Id,\n    });\n\n    return new Dictionary<string, object?>\n    {\n        [\"exampleSecret\"] = example.Secret,\n    };\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\texample, err := cockroach.NewApiKey(ctx, \"example\", &cockroach.ApiKeyArgs{\n\t\t\tName:             pulumi.String(\"An example api key\"),\n\t\t\tServiceAccountId: pulumi.Any(exampleSa.Id),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tctx.Export(\"exampleSecret\", example.Secret)\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.ApiKey;\nimport com.pulumi.cockroach.ApiKeyArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        var example = new ApiKey(\"example\", ApiKeyArgs.builder()\n            .name(\"An example api key\")\n            .serviceAccountId(exampleSa.id())\n            .build());\n\n        ctx.export(\"exampleSecret\", example.secret());\n    }\n}\n```\n```yaml\nresources:\n  example:\n    type: cockroach:ApiKey\n    properties:\n      name: An example api key\n      serviceAccountId: ${exampleSa.id}\noutputs:\n  exampleSecret: ${example.secret}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nSince the secret, is not retreivable after creation, it must be provided\n\nduring import.  The API key ID can be derived from the secret.\n\n```sh\n$ pulumi import cockroach:index/apiKey:ApiKey format: <resource> <api key secret>\n```\n\n```sh\n$ pulumi import cockroach:index/apiKey:ApiKey example CCDB1_D4zMI3pZTmk5rGrzYqMhbc_NkcXLI8d81Mtx3djD45iwPfgtnaRv0XCh0Z9047K\n```\n\n",
      "properties": {
        "createdAt": {
          "type": "string",
          "description": "Creation time of the api key.\n"
        },
        "name": {
          "type": "string",
          "description": "Name of the api key.\n"
        },
        "secret": {
          "type": "string",
          "secret": true
        },
        "serviceAccountId": {
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "createdAt",
        "name",
        "secret",
        "serviceAccountId"
      ],
      "inputProperties": {
        "name": {
          "type": "string",
          "description": "Name of the api key.\n"
        },
        "serviceAccountId": {
          "type": "string"
        }
      },
      "requiredInputs": [
        "serviceAccountId"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering ApiKey resources.\n",
        "properties": {
          "createdAt": {
            "type": "string",
            "description": "Creation time of the api key.\n"
          },
          "name": {
            "type": "string",
            "description": "Name of the api key.\n"
          },
          "secret": {
            "type": "string",
            "secret": true
          },
          "serviceAccountId": {
            "type": "string"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/caCert:CaCert": {
      "description": "Manages client CA certs.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst config = new pulumi.Config();\n// The X509 certificate in PEM format.\nconst clientCertificate = config.require(\"clientCertificate\");\nconst prod = new cockroach.CaCert(\"prod\", {\n    clusterId: prodCockroachCluster.id,\n    x509PemCert: clientCertificate,\n});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nconfig = pulumi.Config()\n# The X509 certificate in PEM format.\nclient_certificate = config.require(\"clientCertificate\")\nprod = cockroach.CaCert(\"prod\",\n    cluster_id=prod_cockroach_cluster[\"id\"],\n    x509_pem_cert=client_certificate)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var config = new Config();\n    // The X509 certificate in PEM format.\n    var clientCertificate = config.Require(\"clientCertificate\");\n    var prod = new Cockroach.CaCert(\"prod\", new()\n    {\n        ClusterId = prodCockroachCluster.Id,\n        X509PemCert = clientCertificate,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\t// The X509 certificate in PEM format.\n\t\tclientCertificate := cfg.Require(\"clientCertificate\")\n\t\t_, err := cockroach.NewCaCert(ctx, \"prod\", &cockroach.CaCertArgs{\n\t\t\tClusterId:   pulumi.Any(prodCockroachCluster.Id),\n\t\t\tX509PemCert: pulumi.String(clientCertificate),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.CaCert;\nimport com.pulumi.cockroach.CaCertArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clientCertificate = config.get(\"clientCertificate\");\n        var prod = new CaCert(\"prod\", CaCertArgs.builder()\n            .clusterId(prodCockroachCluster.id())\n            .x509PemCert(clientCertificate)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clientCertificate:\n    type: string\nresources:\n  prod:\n    type: cockroach:CaCert\n    properties:\n      clusterId: ${prodCockroachCluster.id}\n      x509PemCert: ${clientCertificate}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>\n\n```sh\n$ pulumi import cockroach:index/caCert:CaCert prod 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "status": {
          "type": "string",
          "description": "Status of client CA certs on a cluster.\n"
        },
        "x509PemCert": {
          "type": "string",
          "description": "X509 certificate in PEM format.\n"
        }
      },
      "type": "object",
      "required": [
        "clusterId",
        "status",
        "x509PemCert"
      ],
      "inputProperties": {
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "x509PemCert": {
          "type": "string",
          "description": "X509 certificate in PEM format.\n"
        }
      },
      "requiredInputs": [
        "clusterId",
        "x509PemCert"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering CaCert resources.\n",
        "properties": {
          "clusterId": {
            "type": "string",
            "description": "Cluster ID.\n"
          },
          "status": {
            "type": "string",
            "description": "Status of client CA certs on a cluster.\n"
          },
          "x509PemCert": {
            "type": "string",
            "description": "X509 certificate in PEM format.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/cluster:Cluster": {
      "description": "CockroachDB Cloud cluster.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.Cluster;\nimport com.pulumi.cockroach.ClusterArgs;\nimport com.pulumi.cockroach.inputs.ClusterDedicatedArgs;\nimport com.pulumi.cockroach.inputs.ClusterRegionArgs;\nimport com.pulumi.cockroach.inputs.ClusterBackupConfigArgs;\nimport com.pulumi.cockroach.inputs.ClusterServerlessArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        var advanced = new Cluster(\"advanced\", ClusterArgs.builder()\n            .name(\"cockroach-advanced\")\n            .cloudProvider(\"GCP\")\n            .plan(\"ADVANCED\")\n            .dedicated(ClusterDedicatedArgs.builder()\n                .storage_gib(15)\n                .num_virtual_cpus(4)\n                .build())\n            .regions(ClusterRegionArgs.builder()\n                .name(\"us-central1\")\n                .node_count(1)\n                .build())\n            .deleteProtection(true)\n            .backupConfig(ClusterBackupConfigArgs.builder()\n                .enabled(true)\n                .frequency_minutes(60)\n                .retention_days(30)\n                .build())\n            .build());\n\n        var standard = new Cluster(\"standard\", ClusterArgs.builder()\n            .name(\"cockroach-standard\")\n            .cloudProvider(\"GCP\")\n            .plan(\"STANDARD\")\n            .serverless(ClusterServerlessArgs.builder()\n                .usage_limits(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))\n                .upgrade_type(\"AUTOMATIC\")\n                .build())\n            .regions(ClusterRegionArgs.builder()\n                .name(\"us-east1\")\n                .build())\n            .deleteProtection(false)\n            .backupConfig(ClusterBackupConfigArgs.builder()\n                .enabled(true)\n                .frequency_minutes(60)\n                .retention_days(30)\n                .build())\n            .build());\n\n        var basic = new Cluster(\"basic\", ClusterArgs.builder()\n            .name(\"cockroach-basic\")\n            .cloudProvider(\"GCP\")\n            .plan(\"BASIC\")\n            .serverless()\n            .regions(ClusterRegionArgs.builder()\n                .name(\"us-east1\")\n                .build())\n            .deleteProtection(false)\n            .build());\n\n    }\n}\n```\n```yaml\nresources:\n  advanced:\n    type: cockroach:Cluster\n    properties:\n      name: cockroach-advanced\n      cloudProvider: GCP\n      plan: ADVANCED\n      dedicated:\n        storage_gib: 15\n        num_virtual_cpus: 4\n      regions:\n        - name: us-central1\n          node_count: 1\n      deleteProtection: true\n      backupConfig:\n        enabled: true\n        frequency_minutes: 60\n        retention_days: 30\n  standard:\n    type: cockroach:Cluster\n    properties:\n      name: cockroach-standard\n      cloudProvider: GCP\n      plan: STANDARD\n      serverless:\n        usage_limits:\n          provisionedVirtualCpus: 2\n        upgrade_type: AUTOMATIC\n      regions:\n        - name: us-east1\n      deleteProtection: false\n      backupConfig:\n        enabled: true\n        frequency_minutes: 60\n        retention_days: 30\n  basic:\n    type: cockroach:Cluster\n    properties:\n      name: cockroach-basic\n      cloudProvider: GCP\n      plan: BASIC\n      serverless: {}\n      regions:\n        - name: us-east1\n      deleteProtection: false\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>\n\n```sh\n$ pulumi import cockroach:index/cluster:Cluster my_cluster 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "accountId": {
          "type": "string",
          "description": "The cloud provider account ID that hosts the cluster. Needed for CMEK and other advanced features.\n"
        },
        "backupConfig": {
          "$ref": "#/types/cockroach:index%2FClusterBackupConfig:ClusterBackupConfig",
          "description": "The backup settings for a cluster. Each cluster has backup settings that determine if backups are enabled, how\nfrequently they are taken, and how long they are retained for. Use this attribute to manage those settings.\n"
        },
        "cloudProvider": {
          "type": "string",
          "description": "Cloud provider used to host the cluster. Allowed values are: * GCP * AWS * AZURE\n"
        },
        "cockroachVersion": {
          "type": "string",
          "description": "Major version of CockroachDB running on the cluster. This value can be used to orchestrate version upgrades. Supported\nfor ADVANCED and STANDARD clusters (when `serverless.upgrade_type` set to 'MANUAL').\n"
        },
        "creatorId": {
          "type": "string",
          "description": "ID of the user who created the cluster.\n"
        },
        "dedicated": {
          "$ref": "#/types/cockroach:index%2FClusterDedicated:ClusterDedicated"
        },
        "deleteProtection": {
          "type": "boolean",
          "description": "Set to true to enable delete protection on the cluster. If unset, the server chooses the value on cluster creation, and\npreserves the value on cluster update.\n"
        },
        "name": {
          "type": "string",
          "description": "Name of the cluster.\n"
        },
        "operationStatus": {
          "type": "string",
          "description": "Describes the current long-running operation, if any.\n"
        },
        "parentId": {
          "type": "string",
          "description": "The ID of the cluster's parent folder. 'root' is used for a cluster at the root level.\n"
        },
        "plan": {
          "type": "string",
          "description": "Denotes cluster plan type: 'BASIC' or 'STANDARD' or 'ADVANCED'.\n"
        },
        "regions": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FClusterRegion:ClusterRegion"
          }
        },
        "serverless": {
          "$ref": "#/types/cockroach:index%2FClusterServerless:ClusterServerless"
        },
        "state": {
          "type": "string",
          "description": "Describes whether the cluster is being created, updated, deleted, etc.\n"
        },
        "upgradeStatus": {
          "type": "string",
          "description": "Describes the status of any in-progress CockroachDB upgrade or rollback.\n"
        }
      },
      "type": "object",
      "required": [
        "accountId",
        "backupConfig",
        "cloudProvider",
        "cockroachVersion",
        "creatorId",
        "deleteProtection",
        "name",
        "operationStatus",
        "parentId",
        "plan",
        "regions",
        "state",
        "upgradeStatus"
      ],
      "inputProperties": {
        "backupConfig": {
          "$ref": "#/types/cockroach:index%2FClusterBackupConfig:ClusterBackupConfig",
          "description": "The backup settings for a cluster. Each cluster has backup settings that determine if backups are enabled, how\nfrequently they are taken, and how long they are retained for. Use this attribute to manage those settings.\n"
        },
        "cloudProvider": {
          "type": "string",
          "description": "Cloud provider used to host the cluster. Allowed values are: * GCP * AWS * AZURE\n"
        },
        "cockroachVersion": {
          "type": "string",
          "description": "Major version of CockroachDB running on the cluster. This value can be used to orchestrate version upgrades. Supported\nfor ADVANCED and STANDARD clusters (when `serverless.upgrade_type` set to 'MANUAL').\n"
        },
        "dedicated": {
          "$ref": "#/types/cockroach:index%2FClusterDedicated:ClusterDedicated"
        },
        "deleteProtection": {
          "type": "boolean",
          "description": "Set to true to enable delete protection on the cluster. If unset, the server chooses the value on cluster creation, and\npreserves the value on cluster update.\n"
        },
        "name": {
          "type": "string",
          "description": "Name of the cluster.\n"
        },
        "parentId": {
          "type": "string",
          "description": "The ID of the cluster's parent folder. 'root' is used for a cluster at the root level.\n"
        },
        "plan": {
          "type": "string",
          "description": "Denotes cluster plan type: 'BASIC' or 'STANDARD' or 'ADVANCED'.\n"
        },
        "regions": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FClusterRegion:ClusterRegion"
          }
        },
        "serverless": {
          "$ref": "#/types/cockroach:index%2FClusterServerless:ClusterServerless"
        }
      },
      "requiredInputs": [
        "cloudProvider",
        "regions"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering Cluster resources.\n",
        "properties": {
          "accountId": {
            "type": "string",
            "description": "The cloud provider account ID that hosts the cluster. Needed for CMEK and other advanced features.\n"
          },
          "backupConfig": {
            "$ref": "#/types/cockroach:index%2FClusterBackupConfig:ClusterBackupConfig",
            "description": "The backup settings for a cluster. Each cluster has backup settings that determine if backups are enabled, how\nfrequently they are taken, and how long they are retained for. Use this attribute to manage those settings.\n"
          },
          "cloudProvider": {
            "type": "string",
            "description": "Cloud provider used to host the cluster. Allowed values are: * GCP * AWS * AZURE\n"
          },
          "cockroachVersion": {
            "type": "string",
            "description": "Major version of CockroachDB running on the cluster. This value can be used to orchestrate version upgrades. Supported\nfor ADVANCED and STANDARD clusters (when `serverless.upgrade_type` set to 'MANUAL').\n"
          },
          "creatorId": {
            "type": "string",
            "description": "ID of the user who created the cluster.\n"
          },
          "dedicated": {
            "$ref": "#/types/cockroach:index%2FClusterDedicated:ClusterDedicated"
          },
          "deleteProtection": {
            "type": "boolean",
            "description": "Set to true to enable delete protection on the cluster. If unset, the server chooses the value on cluster creation, and\npreserves the value on cluster update.\n"
          },
          "name": {
            "type": "string",
            "description": "Name of the cluster.\n"
          },
          "operationStatus": {
            "type": "string",
            "description": "Describes the current long-running operation, if any.\n"
          },
          "parentId": {
            "type": "string",
            "description": "The ID of the cluster's parent folder. 'root' is used for a cluster at the root level.\n"
          },
          "plan": {
            "type": "string",
            "description": "Denotes cluster plan type: 'BASIC' or 'STANDARD' or 'ADVANCED'.\n"
          },
          "regions": {
            "type": "array",
            "items": {
              "$ref": "#/types/cockroach:index%2FClusterRegion:ClusterRegion"
            }
          },
          "serverless": {
            "$ref": "#/types/cockroach:index%2FClusterServerless:ClusterServerless"
          },
          "state": {
            "type": "string",
            "description": "Describes whether the cluster is being created, updated, deleted, etc.\n"
          },
          "upgradeStatus": {
            "type": "string",
            "description": "Describes the status of any in-progress CockroachDB upgrade or rollback.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/cmek:Cmek": {
      "description": "Customer-managed encryption keys (CMEK) resource for a single cluster.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst advanced = new cockroach.Cmek(\"advanced\", {\n    clusterId: advancedCockroachCluster.id,\n    regions: [{\n        region: \"us-central-1\",\n        key: {\n            authPrincipal: \"arn:aws:iam::account:role/role-name-with-path\",\n            type: \"AWS_KMS\",\n            uri: \"arn:aws:kms:us-west-2:111122223333:key/id-of-kms-key\",\n        },\n    }],\n});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nadvanced = cockroach.Cmek(\"advanced\",\n    cluster_id=advanced_cockroach_cluster[\"id\"],\n    regions=[{\n        \"region\": \"us-central-1\",\n        \"key\": {\n            \"auth_principal\": \"arn:aws:iam::account:role/role-name-with-path\",\n            \"type\": \"AWS_KMS\",\n            \"uri\": \"arn:aws:kms:us-west-2:111122223333:key/id-of-kms-key\",\n        },\n    }])\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var advanced = new Cockroach.Cmek(\"advanced\", new()\n    {\n        ClusterId = advancedCockroachCluster.Id,\n        Regions = new[]\n        {\n            new Cockroach.Inputs.CmekRegionArgs\n            {\n                Region = \"us-central-1\",\n                Key = new Cockroach.Inputs.CmekRegionKeyArgs\n                {\n                    AuthPrincipal = \"arn:aws:iam::account:role/role-name-with-path\",\n                    Type = \"AWS_KMS\",\n                    Uri = \"arn:aws:kms:us-west-2:111122223333:key/id-of-kms-key\",\n                },\n            },\n        },\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\t_, err := cockroach.NewCmek(ctx, \"advanced\", &cockroach.CmekArgs{\n\t\t\tClusterId: pulumi.Any(advancedCockroachCluster.Id),\n\t\t\tRegions: cockroach.CmekRegionArray{\n\t\t\t\t&cockroach.CmekRegionArgs{\n\t\t\t\t\tRegion: pulumi.String(\"us-central-1\"),\n\t\t\t\t\tKey: &cockroach.CmekRegionKeyArgs{\n\t\t\t\t\t\tAuthPrincipal: pulumi.String(\"arn:aws:iam::account:role/role-name-with-path\"),\n\t\t\t\t\t\tType:          pulumi.String(\"AWS_KMS\"),\n\t\t\t\t\t\tUri:           pulumi.String(\"arn:aws:kms:us-west-2:111122223333:key/id-of-kms-key\"),\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.Cmek;\nimport com.pulumi.cockroach.CmekArgs;\nimport com.pulumi.cockroach.inputs.CmekRegionArgs;\nimport com.pulumi.cockroach.inputs.CmekRegionKeyArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        var advanced = new Cmek(\"advanced\", CmekArgs.builder()\n            .clusterId(advancedCockroachCluster.id())\n            .regions(CmekRegionArgs.builder()\n                .region(\"us-central-1\")\n                .key(CmekRegionKeyArgs.builder()\n                    .authPrincipal(\"arn:aws:iam::account:role/role-name-with-path\")\n                    .type(\"AWS_KMS\")\n                    .uri(\"arn:aws:kms:us-west-2:111122223333:key/id-of-kms-key\")\n                    .build())\n                .build())\n            .build());\n\n    }\n}\n```\n```yaml\nresources:\n  advanced:\n    type: cockroach:Cmek\n    properties:\n      clusterId: ${advancedCockroachCluster.id}\n      regions:\n        - region: us-central-1\n          key:\n            authPrincipal: arn:aws:iam::account:role/role-name-with-path\n            type: AWS_KMS\n            uri: arn:aws:kms:us-west-2:111122223333:key/id-of-kms-key\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>\n\n```sh\n$ pulumi import cockroach:index/cmek:Cmek advanced 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "additionalRegions": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FCmekAdditionalRegion:CmekAdditionalRegion"
          },
          "description": "Once CMEK is enabled for a cluster, no new regions can be added to the cluster resource, since they need encryption key\ninfo stored in the CMEK resource. New regions can be added and maintained here instead.\n"
        },
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "regions": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FCmekRegion:CmekRegion"
          }
        },
        "status": {
          "type": "string",
          "description": "Aggregated status of the cluster's encryption key(s).\n"
        }
      },
      "type": "object",
      "required": [
        "clusterId",
        "regions",
        "status"
      ],
      "inputProperties": {
        "additionalRegions": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FCmekAdditionalRegion:CmekAdditionalRegion"
          },
          "description": "Once CMEK is enabled for a cluster, no new regions can be added to the cluster resource, since they need encryption key\ninfo stored in the CMEK resource. New regions can be added and maintained here instead.\n"
        },
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "regions": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FCmekRegion:CmekRegion"
          }
        },
        "status": {
          "type": "string",
          "description": "Aggregated status of the cluster's encryption key(s).\n"
        }
      },
      "requiredInputs": [
        "clusterId",
        "regions"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering Cmek resources.\n",
        "properties": {
          "additionalRegions": {
            "type": "array",
            "items": {
              "$ref": "#/types/cockroach:index%2FCmekAdditionalRegion:CmekAdditionalRegion"
            },
            "description": "Once CMEK is enabled for a cluster, no new regions can be added to the cluster resource, since they need encryption key\ninfo stored in the CMEK resource. New regions can be added and maintained here instead.\n"
          },
          "clusterId": {
            "type": "string",
            "description": "Cluster ID.\n"
          },
          "regions": {
            "type": "array",
            "items": {
              "$ref": "#/types/cockroach:index%2FCmekRegion:CmekRegion"
            }
          },
          "status": {
            "type": "string",
            "description": "Aggregated status of the cluster's encryption key(s).\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/database:Database": {
      "description": "CockroachDB database.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst cockroach = new cockroach.Database(\"cockroach\", {\n    name: \"example-database\",\n    clusterId: clusterId,\n});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\ncockroach = cockroach.Database(\"cockroach\",\n    name=\"example-database\",\n    cluster_id=cluster_id)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var cockroach = new Cockroach.Database(\"cockroach\", new()\n    {\n        Name = \"example-database\",\n        ClusterId = clusterId,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\t_, err := cockroach.NewDatabase(ctx, \"cockroach\", &cockroach.DatabaseArgs{\n\t\t\tName:      pulumi.String(\"example-database\"),\n\t\t\tClusterId: pulumi.String(clusterId),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.Database;\nimport com.pulumi.cockroach.DatabaseArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        var cockroach = new Database(\"cockroach\", DatabaseArgs.builder()\n            .name(\"example-database\")\n            .clusterId(clusterId)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\nresources:\n  cockroach:\n    type: cockroach:Database\n    properties:\n      name: example-database\n      clusterId: ${clusterId}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>:<database name>\n\n```sh\n$ pulumi import cockroach:index/database:Database my_database 1f69fdd2-600a-4cfc-a9ba-16995df0d77d:mydatabase\n```\n\n",
      "properties": {
        "clusterId": {
          "type": "string",
          "description": "ID of the cluster the database belongs to.\n"
        },
        "name": {
          "type": "string",
          "description": "Database name.\n"
        },
        "tableCount": {
          "type": "integer",
          "description": "Number of tables in the database.\n"
        }
      },
      "type": "object",
      "required": [
        "clusterId",
        "name",
        "tableCount"
      ],
      "inputProperties": {
        "clusterId": {
          "type": "string",
          "description": "ID of the cluster the database belongs to.\n"
        },
        "name": {
          "type": "string",
          "description": "Database name.\n"
        }
      },
      "requiredInputs": [
        "clusterId"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering Database resources.\n",
        "properties": {
          "clusterId": {
            "type": "string",
            "description": "ID of the cluster the database belongs to.\n"
          },
          "name": {
            "type": "string",
            "description": "Database name.\n"
          },
          "tableCount": {
            "type": "integer",
            "description": "Number of tables in the database.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/finalizeVersionUpgrade:FinalizeVersionUpgrade": {
      "description": "Utility resource that represents the one-time action of finalizing a cluster's pending CockroachDB version upgrade.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst cockroachVersion = config.require(\"cockroachVersion\");\nconst cockroach = new cockroach.FinalizeVersionUpgrade(\"cockroach\", {\n    clusterId: clusterId,\n    cockroachVersion: cockroachVersion,\n});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\ncockroach_version = config.require(\"cockroachVersion\")\ncockroach = cockroach.FinalizeVersionUpgrade(\"cockroach\",\n    cluster_id=cluster_id,\n    cockroach_version=cockroach_version)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var cockroachVersion = config.Require(\"cockroachVersion\");\n    var cockroach = new Cockroach.FinalizeVersionUpgrade(\"cockroach\", new()\n    {\n        ClusterId = clusterId,\n        CockroachVersion = cockroachVersion,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\tcockroachVersion := cfg.Require(\"cockroachVersion\")\n\t\t_, err := cockroach.NewFinalizeVersionUpgrade(ctx, \"cockroach\", &cockroach.FinalizeVersionUpgradeArgs{\n\t\t\tClusterId:        pulumi.String(clusterId),\n\t\t\tCockroachVersion: pulumi.String(cockroachVersion),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.FinalizeVersionUpgrade;\nimport com.pulumi.cockroach.FinalizeVersionUpgradeArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        final var cockroachVersion = config.get(\"cockroachVersion\");\n        var cockroach = new FinalizeVersionUpgrade(\"cockroach\", FinalizeVersionUpgradeArgs.builder()\n            .clusterId(clusterId)\n            .cockroachVersion(cockroachVersion)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\n  cockroachVersion:\n    type: string\nresources:\n  cockroach:\n    type: cockroach:FinalizeVersionUpgrade\n    properties:\n      clusterId: ${clusterId}\n      cockroachVersion: ${cockroachVersion}\n```\n<!--End PulumiCodeChooser -->\n",
      "properties": {
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "cockroachVersion": {
          "type": "string",
          "description": "Major version of the cluster to be finalized.\n"
        }
      },
      "type": "object",
      "required": [
        "clusterId",
        "cockroachVersion"
      ],
      "inputProperties": {
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "cockroachVersion": {
          "type": "string",
          "description": "Major version of the cluster to be finalized.\n"
        }
      },
      "requiredInputs": [
        "clusterId",
        "cockroachVersion"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering FinalizeVersionUpgrade resources.\n",
        "properties": {
          "clusterId": {
            "type": "string",
            "description": "Cluster ID.\n"
          },
          "cockroachVersion": {
            "type": "string",
            "description": "Major version of the cluster to be finalized.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/folder:Folder": {
      "description": "CockroachDB Cloud folder.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst aTeam = new cockroach.Folder(\"a_team\", {\n    name: \"a-team\",\n    parentId: \"root\",\n});\nconst aTeamDev = new cockroach.Folder(\"a_team_dev\", {\n    name: \"dev\",\n    parentId: aTeam.id,\n});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\na_team = cockroach.Folder(\"a_team\",\n    name=\"a-team\",\n    parent_id=\"root\")\na_team_dev = cockroach.Folder(\"a_team_dev\",\n    name=\"dev\",\n    parent_id=a_team.id)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var aTeam = new Cockroach.Folder(\"a_team\", new()\n    {\n        Name = \"a-team\",\n        ParentId = \"root\",\n    });\n\n    var aTeamDev = new Cockroach.Folder(\"a_team_dev\", new()\n    {\n        Name = \"dev\",\n        ParentId = aTeam.Id,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\taTeam, err := cockroach.NewFolder(ctx, \"a_team\", &cockroach.FolderArgs{\n\t\t\tName:     pulumi.String(\"a-team\"),\n\t\t\tParentId: pulumi.String(\"root\"),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\t_, err = cockroach.NewFolder(ctx, \"a_team_dev\", &cockroach.FolderArgs{\n\t\t\tName:     pulumi.String(\"dev\"),\n\t\t\tParentId: aTeam.ID(),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.Folder;\nimport com.pulumi.cockroach.FolderArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        var aTeam = new Folder(\"aTeam\", FolderArgs.builder()\n            .name(\"a-team\")\n            .parentId(\"root\")\n            .build());\n\n        var aTeamDev = new Folder(\"aTeamDev\", FolderArgs.builder()\n            .name(\"dev\")\n            .parentId(aTeam.id())\n            .build());\n\n    }\n}\n```\n```yaml\nresources:\n  aTeam:\n    type: cockroach:Folder\n    name: a_team\n    properties:\n      name: a-team\n      parentId: root\n  aTeamDev:\n    type: cockroach:Folder\n    name: a_team_dev\n    properties:\n      name: dev\n      parentId: ${aTeam.id}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <folder id>\n\n```sh\n$ pulumi import cockroach:index/folder:Folder my_folder 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "name": {
          "type": "string",
          "description": "Name of the folder.\n"
        },
        "parentId": {
          "type": "string",
          "description": "ID of the parent folder. Use 'root' for the root level (no parent folder).\n"
        }
      },
      "type": "object",
      "required": [
        "name",
        "parentId"
      ],
      "inputProperties": {
        "name": {
          "type": "string",
          "description": "Name of the folder.\n"
        },
        "parentId": {
          "type": "string",
          "description": "ID of the parent folder. Use 'root' for the root level (no parent folder).\n"
        }
      },
      "requiredInputs": [
        "parentId"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering Folder resources.\n",
        "properties": {
          "name": {
            "type": "string",
            "description": "Name of the folder.\n"
          },
          "parentId": {
            "type": "string",
            "description": "ID of the parent folder. Use 'root' for the root level (no parent folder).\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/jwtIssuer:JwtIssuer": {
      "description": "Configuration to manage external JSON Web Token (JWT) Issuers for authentication to the CockroachDB Cloud API.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.JwtIssuer;\nimport com.pulumi.cockroach.JwtIssuerArgs;\nimport com.pulumi.cockroach.inputs.JwtIssuerIdentityMapArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        var example = new JwtIssuer(\"example\", JwtIssuerArgs.builder()\n            .issuerUrl(\"https://accounts.google.com\")\n            .audience(\"test_audience\")\n            .jwks(\"{\\\"keys\\\":[{\\\"alg\\\":\\\"RS256\\\",\\\"e\\\":\\\"AQAB\\\",\\\"kid\\\":\\\"test_kid1\\\",\\\"kty\\\":\\\"RSA\\\",\\\"n\\\":\\\"09lq1lCEuteonwDJOhGTDak11ThplZuC9JEWQNdBnBSQwlkJQIE7A7nTBO0xTibcsh2HwYkC-N_Gs1jP4iwN3dRqnu5FwG2ct5mY8KLwJiHzToFC0MKenSFQCy0FviNtOnpiObcUlDvR2NDeNtMl_6SPzcQEt7GUTBBYZgoAxPmOgevki6ZNO6Y86xFqx3y6v8EPwW010AiC60r4AHGCTBhYF4uqmq5JH2UU4dDh9Udc-9LZxlSqPwJvnKDG2GjcnD8TsU3wjfEM_nRmx3dnXsrZUXYfNGtdv5dlHywf5AhkJmTavqcsJkgrNA-PNBghFMcCR816_kCIkCYWLWC5vQ\\\"}]}\")\n            .claim(\"email\")\n            .identityMaps(            \n                JwtIssuerIdentityMapArgs.builder()\n                    .token_identity(\"test_user\")\n                    .cc_identity(\"abc@example.com\")\n                    .build(),\n                JwtIssuerIdentityMapArgs.builder()\n                    .token_identity(\"/^sso_(.*)$\")\n                    .cc_identity(\"\\\\1@example.com\")\n                    .build())\n            .build());\n\n    }\n}\n```\n```yaml\nresources:\n  example:\n    type: cockroach:JwtIssuer\n    properties:\n      issuerUrl: https://accounts.google.com\n      audience: test_audience\n      jwks: '{\"keys\":[{\"alg\":\"RS256\",\"e\":\"AQAB\",\"kid\":\"test_kid1\",\"kty\":\"RSA\",\"n\":\"09lq1lCEuteonwDJOhGTDak11ThplZuC9JEWQNdBnBSQwlkJQIE7A7nTBO0xTibcsh2HwYkC-N_Gs1jP4iwN3dRqnu5FwG2ct5mY8KLwJiHzToFC0MKenSFQCy0FviNtOnpiObcUlDvR2NDeNtMl_6SPzcQEt7GUTBBYZgoAxPmOgevki6ZNO6Y86xFqx3y6v8EPwW010AiC60r4AHGCTBhYF4uqmq5JH2UU4dDh9Udc-9LZxlSqPwJvnKDG2GjcnD8TsU3wjfEM_nRmx3dnXsrZUXYfNGtdv5dlHywf5AhkJmTavqcsJkgrNA-PNBghFMcCR816_kCIkCYWLWC5vQ\"}]}'\n      claim: email\n      identityMaps:\n        - token_identity: test_user\n          cc_identity: abc@example.com\n        - token_identity: /^sso_(.*)$\n          cc_identity: \\1@example.com\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nJWT Issuer ID can be found by running a GET against the Cockroach Cloud API to\n\nlist all existing JWT issuers.\n\nhttps://www.cockroachlabs.com/docs/api/cloud/v1#get-/api/v1/jwt-issuers\n\nformat: <jwt issuer id>\n\n```sh\n$ pulumi import cockroach:index/jwtIssuer:JwtIssuer my_issuer 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "audience": {
          "type": "string",
          "description": "The intended audience for consuming the JWT.\n"
        },
        "claim": {
          "type": "string",
          "description": "Used to identify the user from the external Identity Provider. Defaults to \"sub\".\n"
        },
        "identityMaps": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FJwtIssuerIdentityMap:JwtIssuerIdentityMap"
          },
          "description": "A list of mappings to map the external token identity into CockroachDB Cloud.\n"
        },
        "issuerUrl": {
          "type": "string",
          "description": "The URL of the server issuing JWTs.\n"
        },
        "jwks": {
          "type": "string",
          "description": "A set of public keys (JWKS) used to verify the JWT.\n"
        }
      },
      "type": "object",
      "required": [
        "audience",
        "issuerUrl"
      ],
      "inputProperties": {
        "audience": {
          "type": "string",
          "description": "The intended audience for consuming the JWT.\n"
        },
        "claim": {
          "type": "string",
          "description": "Used to identify the user from the external Identity Provider. Defaults to \"sub\".\n"
        },
        "identityMaps": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FJwtIssuerIdentityMap:JwtIssuerIdentityMap"
          },
          "description": "A list of mappings to map the external token identity into CockroachDB Cloud.\n"
        },
        "issuerUrl": {
          "type": "string",
          "description": "The URL of the server issuing JWTs.\n"
        },
        "jwks": {
          "type": "string",
          "description": "A set of public keys (JWKS) used to verify the JWT.\n"
        }
      },
      "requiredInputs": [
        "audience",
        "issuerUrl"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering JwtIssuer resources.\n",
        "properties": {
          "audience": {
            "type": "string",
            "description": "The intended audience for consuming the JWT.\n"
          },
          "claim": {
            "type": "string",
            "description": "Used to identify the user from the external Identity Provider. Defaults to \"sub\".\n"
          },
          "identityMaps": {
            "type": "array",
            "items": {
              "$ref": "#/types/cockroach:index%2FJwtIssuerIdentityMap:JwtIssuerIdentityMap"
            },
            "description": "A list of mappings to map the external token identity into CockroachDB Cloud.\n"
          },
          "issuerUrl": {
            "type": "string",
            "description": "The URL of the server issuing JWTs.\n"
          },
          "jwks": {
            "type": "string",
            "description": "A set of public keys (JWKS) used to verify the JWT.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/logExportConfig:LogExportConfig": {
      "description": "Log Export configuration for a cluster.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.LogExportConfig;\nimport com.pulumi.cockroach.LogExportConfigArgs;\nimport com.pulumi.cockroach.inputs.LogExportConfigGroupArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        final var authPrincipal = config.get(\"authPrincipal\");\n        var example = new LogExportConfig(\"example\", LogExportConfigArgs.builder()\n            .clusterId(clusterId)\n            .authPrincipal(authPrincipal)\n            .logName(\"example\")\n            .type(\"GCP_CLOUD_LOGGING\")\n            .redact(true)\n            .groups(            \n                LogExportConfigGroupArgs.builder()\n                    .log_name(\"sql\")\n                    .channels(                    \n                        \"SQL_SCHEMA\",\n                        \"SQL_EXEC\")\n                    .redact(false)\n                    .build(),\n                LogExportConfigGroupArgs.builder()\n                    .log_name(\"devops\")\n                    .channels(                    \n                        \"OPS\",\n                        \"HEALTH\",\n                        \"STORAGE\")\n                    .min_level(\"WARNING\")\n                    .build())\n            .omittedChannels(\"SQL_PERF\")\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\n  authPrincipal:\n    type: string\nresources:\n  example:\n    type: cockroach:LogExportConfig\n    properties:\n      clusterId: ${clusterId}\n      authPrincipal: ${authPrincipal}\n      logName: example\n      type: GCP_CLOUD_LOGGING\n      redact: true\n      groups:\n        - log_name: sql\n          channels:\n            - SQL_SCHEMA\n            - SQL_EXEC\n          redact: false\n        - log_name: devops\n          channels:\n            - OPS\n            - HEALTH\n            - STORAGE\n          min_level: WARNING\n      omittedChannels:\n        - SQL_PERF\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>\n\n```sh\n$ pulumi import cockroach:index/logExportConfig:LogExportConfig example 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "authPrincipal": {
          "type": "string",
          "description": "Either the AWS Role ARN that identifies a role that the cluster account can assume to write to CloudWatch or the GCP\nProject ID that the cluster service account has permissions to write to for cloud logging.\n"
        },
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "createdAt": {
          "type": "string",
          "description": "Indicates when log export was initially configured.\n"
        },
        "groups": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FLogExportConfigGroup:LogExportConfigGroup"
          }
        },
        "logName": {
          "type": "string",
          "description": "An identifier for the logs in the customer's log sink.\n"
        },
        "omittedChannels": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Controls what CRDB channels do not get exported.\n"
        },
        "redact": {
          "type": "boolean",
          "description": "Controls whether logs are redacted before forwarding to customer sinks.\n"
        },
        "region": {
          "type": "string",
          "description": "Controls whether all logs are sent to a specific region in the customer sink.\n"
        },
        "status": {
          "type": "string",
          "description": "Encodes the possible states that a log export configuration can be in as it is created, deployed, and disabled.\n"
        },
        "type": {
          "type": "string",
          "description": "The cloud selection being exported to along with the cloud logging platform. Possible values are: * AWS_CLOUDWATCH *\nGCP_CLOUD_LOGGING * AZURE_LOG_ANALYTICS\n"
        },
        "updatedAt": {
          "type": "string",
          "description": "Indicates when the log export configuration was last updated.\n"
        },
        "userMessage": {
          "type": "string",
          "description": "Elaborates on the log export status and hints at how to fix issues that may have occurred during asynchronous\noperations.\n"
        }
      },
      "type": "object",
      "required": [
        "authPrincipal",
        "clusterId",
        "createdAt",
        "logName",
        "region",
        "status",
        "type",
        "updatedAt",
        "userMessage"
      ],
      "inputProperties": {
        "authPrincipal": {
          "type": "string",
          "description": "Either the AWS Role ARN that identifies a role that the cluster account can assume to write to CloudWatch or the GCP\nProject ID that the cluster service account has permissions to write to for cloud logging.\n"
        },
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "groups": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FLogExportConfigGroup:LogExportConfigGroup"
          }
        },
        "logName": {
          "type": "string",
          "description": "An identifier for the logs in the customer's log sink.\n"
        },
        "omittedChannels": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Controls what CRDB channels do not get exported.\n"
        },
        "redact": {
          "type": "boolean",
          "description": "Controls whether logs are redacted before forwarding to customer sinks.\n"
        },
        "region": {
          "type": "string",
          "description": "Controls whether all logs are sent to a specific region in the customer sink.\n"
        },
        "type": {
          "type": "string",
          "description": "The cloud selection being exported to along with the cloud logging platform. Possible values are: * AWS_CLOUDWATCH *\nGCP_CLOUD_LOGGING * AZURE_LOG_ANALYTICS\n"
        }
      },
      "requiredInputs": [
        "authPrincipal",
        "clusterId",
        "logName",
        "type"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering LogExportConfig resources.\n",
        "properties": {
          "authPrincipal": {
            "type": "string",
            "description": "Either the AWS Role ARN that identifies a role that the cluster account can assume to write to CloudWatch or the GCP\nProject ID that the cluster service account has permissions to write to for cloud logging.\n"
          },
          "clusterId": {
            "type": "string",
            "description": "Cluster ID.\n"
          },
          "createdAt": {
            "type": "string",
            "description": "Indicates when log export was initially configured.\n"
          },
          "groups": {
            "type": "array",
            "items": {
              "$ref": "#/types/cockroach:index%2FLogExportConfigGroup:LogExportConfigGroup"
            }
          },
          "logName": {
            "type": "string",
            "description": "An identifier for the logs in the customer's log sink.\n"
          },
          "omittedChannels": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Controls what CRDB channels do not get exported.\n"
          },
          "redact": {
            "type": "boolean",
            "description": "Controls whether logs are redacted before forwarding to customer sinks.\n"
          },
          "region": {
            "type": "string",
            "description": "Controls whether all logs are sent to a specific region in the customer sink.\n"
          },
          "status": {
            "type": "string",
            "description": "Encodes the possible states that a log export configuration can be in as it is created, deployed, and disabled.\n"
          },
          "type": {
            "type": "string",
            "description": "The cloud selection being exported to along with the cloud logging platform. Possible values are: * AWS_CLOUDWATCH *\nGCP_CLOUD_LOGGING * AZURE_LOG_ANALYTICS\n"
          },
          "updatedAt": {
            "type": "string",
            "description": "Indicates when the log export configuration was last updated.\n"
          },
          "userMessage": {
            "type": "string",
            "description": "Elaborates on the log export status and hints at how to fix issues that may have occurred during asynchronous\noperations.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/maintenanceWindow:MaintenanceWindow": {
      "description": "Maintenance window configuration for a cluster. Maintenance Windows are supported for Advanced clusters only.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst offsetDuration = config.getNumber(\"offsetDuration\") || 172800;\nconst windowDuration = config.getNumber(\"windowDuration\") || 21600;\nconst example = new cockroach.MaintenanceWindow(\"example\", {\n    clusterId: clusterId,\n    offsetDuration: offsetDuration,\n    windowDuration: windowDuration,\n});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\noffset_duration = config.get_float(\"offsetDuration\")\nif offset_duration is None:\n    offset_duration = 172800\nwindow_duration = config.get_float(\"windowDuration\")\nif window_duration is None:\n    window_duration = 21600\nexample = cockroach.MaintenanceWindow(\"example\",\n    cluster_id=cluster_id,\n    offset_duration=offset_duration,\n    window_duration=window_duration)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var offsetDuration = config.GetDouble(\"offsetDuration\") ?? 172800;\n    var windowDuration = config.GetDouble(\"windowDuration\") ?? 21600;\n    var example = new Cockroach.MaintenanceWindow(\"example\", new()\n    {\n        ClusterId = clusterId,\n        OffsetDuration = offsetDuration,\n        WindowDuration = windowDuration,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\toffsetDuration := float64(172800)\n\t\tif param := cfg.GetFloat64(\"offsetDuration\"); param != 0 {\n\t\t\toffsetDuration = param\n\t\t}\n\t\twindowDuration := float64(21600)\n\t\tif param := cfg.GetFloat64(\"windowDuration\"); param != 0 {\n\t\t\twindowDuration = param\n\t\t}\n\t\t_, err := cockroach.NewMaintenanceWindow(ctx, \"example\", &cockroach.MaintenanceWindowArgs{\n\t\t\tClusterId:      pulumi.String(clusterId),\n\t\t\tOffsetDuration: pulumi.Float64(offsetDuration),\n\t\t\tWindowDuration: pulumi.Float64(windowDuration),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.MaintenanceWindow;\nimport com.pulumi.cockroach.MaintenanceWindowArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        final var offsetDuration = config.get(\"offsetDuration\").orElse(172800);\n        final var windowDuration = config.get(\"windowDuration\").orElse(21600);\n        var example = new MaintenanceWindow(\"example\", MaintenanceWindowArgs.builder()\n            .clusterId(clusterId)\n            .offsetDuration(offsetDuration)\n            .windowDuration(windowDuration)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\n  offsetDuration:\n    type: number\n    default: 172800\n  windowDuration:\n    type: number\n    default: 21600\nresources:\n  example:\n    type: cockroach:MaintenanceWindow\n    properties:\n      clusterId: ${clusterId}\n      offsetDuration: ${offsetDuration}\n      windowDuration: ${windowDuration}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>\n\n```sh\n$ pulumi import cockroach:index/maintenanceWindow:MaintenanceWindow example 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "offsetDuration": {
          "type": "integer",
          "description": "Duration in seconds from the beginning of each Monday (UTC) after which the maintenance window starts.\n"
        },
        "windowDuration": {
          "type": "integer",
          "description": "Duration in seconds that the maintenance window will remain active for after it starts.\n"
        }
      },
      "type": "object",
      "required": [
        "clusterId",
        "offsetDuration",
        "windowDuration"
      ],
      "inputProperties": {
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "offsetDuration": {
          "type": "integer",
          "description": "Duration in seconds from the beginning of each Monday (UTC) after which the maintenance window starts.\n"
        },
        "windowDuration": {
          "type": "integer",
          "description": "Duration in seconds that the maintenance window will remain active for after it starts.\n"
        }
      },
      "requiredInputs": [
        "clusterId",
        "offsetDuration",
        "windowDuration"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering MaintenanceWindow resources.\n",
        "properties": {
          "clusterId": {
            "type": "string",
            "description": "Cluster ID.\n"
          },
          "offsetDuration": {
            "type": "integer",
            "description": "Duration in seconds from the beginning of each Monday (UTC) after which the maintenance window starts.\n"
          },
          "windowDuration": {
            "type": "integer",
            "description": "Duration in seconds that the maintenance window will remain active for after it starts.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/metricExportCloudwatchConfig:MetricExportCloudwatchConfig": {
      "description": "Amazon CloudWatch metric export configuration for a cluster.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst roleArn = config.require(\"roleArn\");\nconst logGroupName = config.require(\"logGroupName\");\nconst awsRegion = config.require(\"awsRegion\");\nconst example = new cockroach.MetricExportCloudwatchConfig(\"example\", {\n    clusterId: clusterId,\n    roleArn: roleArn,\n    logGroupName: logGroupName,\n    targetRegion: awsRegion,\n});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\nrole_arn = config.require(\"roleArn\")\nlog_group_name = config.require(\"logGroupName\")\naws_region = config.require(\"awsRegion\")\nexample = cockroach.MetricExportCloudwatchConfig(\"example\",\n    cluster_id=cluster_id,\n    role_arn=role_arn,\n    log_group_name=log_group_name,\n    target_region=aws_region)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var roleArn = config.Require(\"roleArn\");\n    var logGroupName = config.Require(\"logGroupName\");\n    var awsRegion = config.Require(\"awsRegion\");\n    var example = new Cockroach.MetricExportCloudwatchConfig(\"example\", new()\n    {\n        ClusterId = clusterId,\n        RoleArn = roleArn,\n        LogGroupName = logGroupName,\n        TargetRegion = awsRegion,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\troleArn := cfg.Require(\"roleArn\")\n\t\tlogGroupName := cfg.Require(\"logGroupName\")\n\t\tawsRegion := cfg.Require(\"awsRegion\")\n\t\t_, err := cockroach.NewMetricExportCloudwatchConfig(ctx, \"example\", &cockroach.MetricExportCloudwatchConfigArgs{\n\t\t\tClusterId:    pulumi.String(clusterId),\n\t\t\tRoleArn:      pulumi.String(roleArn),\n\t\t\tLogGroupName: pulumi.String(logGroupName),\n\t\t\tTargetRegion: pulumi.String(awsRegion),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.MetricExportCloudwatchConfig;\nimport com.pulumi.cockroach.MetricExportCloudwatchConfigArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        final var roleArn = config.get(\"roleArn\");\n        final var logGroupName = config.get(\"logGroupName\");\n        final var awsRegion = config.get(\"awsRegion\");\n        var example = new MetricExportCloudwatchConfig(\"example\", MetricExportCloudwatchConfigArgs.builder()\n            .clusterId(clusterId)\n            .roleArn(roleArn)\n            .logGroupName(logGroupName)\n            .targetRegion(awsRegion)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\n  roleArn:\n    type: string\n  logGroupName:\n    type: string\n  awsRegion:\n    type: string\nresources:\n  example:\n    type: cockroach:MetricExportCloudwatchConfig\n    properties:\n      clusterId: ${clusterId}\n      roleArn: ${roleArn}\n      logGroupName: ${logGroupName}\n      targetRegion: ${awsRegion}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>\n\n```sh\n$ pulumi import cockroach:index/metricExportCloudwatchConfig:MetricExportCloudwatchConfig example 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "logGroupName": {
          "type": "string",
          "description": "The customized AWS CloudWatch log group name.\n"
        },
        "roleArn": {
          "type": "string",
          "description": "The IAM role used to upload metric segments to the target AWS account.\n"
        },
        "status": {
          "type": "string",
          "description": "Encodes the possible states that a metric export configuration can be in as it is created, deployed, and disabled.\n"
        },
        "targetRegion": {
          "type": "string",
          "description": "The specific AWS region that the metrics will be exported to.\n"
        },
        "userMessage": {
          "type": "string",
          "description": "Elaborates on the metric export status and hints at how to fix issues that may have occurred during asynchronous operations.\n"
        }
      },
      "type": "object",
      "required": [
        "clusterId",
        "logGroupName",
        "roleArn",
        "status",
        "targetRegion",
        "userMessage"
      ],
      "inputProperties": {
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "logGroupName": {
          "type": "string",
          "description": "The customized AWS CloudWatch log group name.\n"
        },
        "roleArn": {
          "type": "string",
          "description": "The IAM role used to upload metric segments to the target AWS account.\n"
        },
        "targetRegion": {
          "type": "string",
          "description": "The specific AWS region that the metrics will be exported to.\n"
        }
      },
      "requiredInputs": [
        "clusterId",
        "roleArn"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering MetricExportCloudwatchConfig resources.\n",
        "properties": {
          "clusterId": {
            "type": "string",
            "description": "Cluster ID.\n"
          },
          "logGroupName": {
            "type": "string",
            "description": "The customized AWS CloudWatch log group name.\n"
          },
          "roleArn": {
            "type": "string",
            "description": "The IAM role used to upload metric segments to the target AWS account.\n"
          },
          "status": {
            "type": "string",
            "description": "Encodes the possible states that a metric export configuration can be in as it is created, deployed, and disabled.\n"
          },
          "targetRegion": {
            "type": "string",
            "description": "The specific AWS region that the metrics will be exported to.\n"
          },
          "userMessage": {
            "type": "string",
            "description": "Elaborates on the metric export status and hints at how to fix issues that may have occurred during asynchronous operations.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/metricExportDatadogConfig:MetricExportDatadogConfig": {
      "description": "DataDog metric export configuration for a cluster.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst datadogSite = config.require(\"datadogSite\");\nconst datadogApiKey = config.require(\"datadogApiKey\");\nconst example = new cockroach.MetricExportDatadogConfig(\"example\", {\n    clusterId: clusterId,\n    site: datadogSite,\n    apiKey: datadogApiKey,\n});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\ndatadog_site = config.require(\"datadogSite\")\ndatadog_api_key = config.require(\"datadogApiKey\")\nexample = cockroach.MetricExportDatadogConfig(\"example\",\n    cluster_id=cluster_id,\n    site=datadog_site,\n    api_key=datadog_api_key)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var datadogSite = config.Require(\"datadogSite\");\n    var datadogApiKey = config.Require(\"datadogApiKey\");\n    var example = new Cockroach.MetricExportDatadogConfig(\"example\", new()\n    {\n        ClusterId = clusterId,\n        Site = datadogSite,\n        ApiKey = datadogApiKey,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\tdatadogSite := cfg.Require(\"datadogSite\")\n\t\tdatadogApiKey := cfg.Require(\"datadogApiKey\")\n\t\t_, err := cockroach.NewMetricExportDatadogConfig(ctx, \"example\", &cockroach.MetricExportDatadogConfigArgs{\n\t\t\tClusterId: pulumi.String(clusterId),\n\t\t\tSite:      pulumi.String(datadogSite),\n\t\t\tApiKey:    pulumi.String(datadogApiKey),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.MetricExportDatadogConfig;\nimport com.pulumi.cockroach.MetricExportDatadogConfigArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        final var datadogSite = config.get(\"datadogSite\");\n        final var datadogApiKey = config.get(\"datadogApiKey\");\n        var example = new MetricExportDatadogConfig(\"example\", MetricExportDatadogConfigArgs.builder()\n            .clusterId(clusterId)\n            .site(datadogSite)\n            .apiKey(datadogApiKey)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\n  datadogSite:\n    type: string\n  datadogApiKey:\n    type: string\nresources:\n  example:\n    type: cockroach:MetricExportDatadogConfig\n    properties:\n      clusterId: ${clusterId}\n      site: ${datadogSite}\n      apiKey: ${datadogApiKey}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>\n\n```sh\n$ pulumi import cockroach:index/metricExportDatadogConfig:MetricExportDatadogConfig example 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "apiKey": {
          "type": "string",
          "description": "A Datadog API key.\n",
          "secret": true
        },
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "site": {
          "type": "string",
          "description": "The Datadog region to export to.\n"
        },
        "status": {
          "type": "string",
          "description": "Encodes the possible states that a metric export configuration can be in as it is created, deployed, and disabled.\n"
        },
        "userMessage": {
          "type": "string",
          "description": "Elaborates on the metric export status and hints at how to fix issues that may have occurred during asynchronous operations.\n"
        }
      },
      "type": "object",
      "required": [
        "apiKey",
        "clusterId",
        "site",
        "status",
        "userMessage"
      ],
      "inputProperties": {
        "apiKey": {
          "type": "string",
          "description": "A Datadog API key.\n",
          "secret": true
        },
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "site": {
          "type": "string",
          "description": "The Datadog region to export to.\n"
        }
      },
      "requiredInputs": [
        "apiKey",
        "clusterId",
        "site"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering MetricExportDatadogConfig resources.\n",
        "properties": {
          "apiKey": {
            "type": "string",
            "description": "A Datadog API key.\n",
            "secret": true
          },
          "clusterId": {
            "type": "string",
            "description": "Cluster ID.\n"
          },
          "site": {
            "type": "string",
            "description": "The Datadog region to export to.\n"
          },
          "status": {
            "type": "string",
            "description": "Encodes the possible states that a metric export configuration can be in as it is created, deployed, and disabled.\n"
          },
          "userMessage": {
            "type": "string",
            "description": "Elaborates on the metric export status and hints at how to fix issues that may have occurred during asynchronous operations.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/metricExportPrometheusConfig:MetricExportPrometheusConfig": {
      "description": "Prometheus metric export configuration for a cluster. This is only available for dedicated clusters with AWS and GCP cloud providers.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst example = new cockroach.MetricExportPrometheusConfig(\"example\", {clusterId: clusterId});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\nexample = cockroach.MetricExportPrometheusConfig(\"example\", cluster_id=cluster_id)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var example = new Cockroach.MetricExportPrometheusConfig(\"example\", new()\n    {\n        ClusterId = clusterId,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\t_, err := cockroach.NewMetricExportPrometheusConfig(ctx, \"example\", &cockroach.MetricExportPrometheusConfigArgs{\n\t\t\tClusterId: pulumi.String(clusterId),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.MetricExportPrometheusConfig;\nimport com.pulumi.cockroach.MetricExportPrometheusConfigArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        var example = new MetricExportPrometheusConfig(\"example\", MetricExportPrometheusConfigArgs.builder()\n            .clusterId(clusterId)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\nresources:\n  example:\n    type: cockroach:MetricExportPrometheusConfig\n    properties:\n      clusterId: ${clusterId}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>\n\n```sh\n$ pulumi import cockroach:index/metricExportPrometheusConfig:MetricExportPrometheusConfig example 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "status": {
          "type": "string",
          "description": "The current state of the metric export configuration.  Possible values are: [`NOT_DEPLOYED` `DISABLING` `ENABLING` `ENABLED` `ERROR`]\n"
        },
        "targets": {
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        }
      },
      "type": "object",
      "required": [
        "clusterId",
        "status",
        "targets"
      ],
      "inputProperties": {
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        }
      },
      "requiredInputs": [
        "clusterId"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering MetricExportPrometheusConfig resources.\n",
        "properties": {
          "clusterId": {
            "type": "string",
            "description": "Cluster ID.\n"
          },
          "status": {
            "type": "string",
            "description": "The current state of the metric export configuration.  Possible values are: [`NOT_DEPLOYED` `DISABLING` `ENABLING` `ENABLED` `ERROR`]\n"
          },
          "targets": {
            "type": "object",
            "additionalProperties": {
              "type": "string"
            }
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/privateEndpointConnection:PrivateEndpointConnection": {
      "description": "Private endpoint connections allow customer applications to connect to a CockroachDB Cloud cluster without traversing the public internet. All application-database traffic remains within the cloud-provider network.\n\n## Import\n\nformat: <cluster id>:<connection id>\n\n```sh\n$ pulumi import cockroach:index/privateEndpointConnection:PrivateEndpointConnection resource_name 1f69fdd2-600a-4cfc-a9ba-16995df0d77d:vpce-0c1308d7312217abc\n```\n\n",
      "properties": {
        "cloudProvider": {
          "type": "string",
          "description": "Cloud provider associated with this connection.\n"
        },
        "clusterId": {
          "type": "string"
        },
        "endpointId": {
          "type": "string",
          "description": "Client side ID of the Private Endpoint Connection.\n"
        },
        "regionName": {
          "type": "string",
          "description": "Cloud provider region code associated with this connection.\n"
        },
        "serviceId": {
          "type": "string",
          "description": "Server side ID of the Private Endpoint Connection.\n"
        }
      },
      "type": "object",
      "required": [
        "cloudProvider",
        "clusterId",
        "endpointId",
        "regionName",
        "serviceId"
      ],
      "inputProperties": {
        "clusterId": {
          "type": "string"
        },
        "endpointId": {
          "type": "string",
          "description": "Client side ID of the Private Endpoint Connection.\n"
        }
      },
      "requiredInputs": [
        "clusterId",
        "endpointId"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering PrivateEndpointConnection resources.\n",
        "properties": {
          "cloudProvider": {
            "type": "string",
            "description": "Cloud provider associated with this connection.\n"
          },
          "clusterId": {
            "type": "string"
          },
          "endpointId": {
            "type": "string",
            "description": "Client side ID of the Private Endpoint Connection.\n"
          },
          "regionName": {
            "type": "string",
            "description": "Cloud provider region code associated with this connection.\n"
          },
          "serviceId": {
            "type": "string",
            "description": "Server side ID of the Private Endpoint Connection.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/privateEndpointServices:PrivateEndpointServices": {
      "description": "PrivateEndpointServices contains services that allow for private connectivity to the CockroachDB Cloud cluster.\n\t\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst cockroach = new cockroach.PrivateEndpointServices(\"cockroach\", {clusterId: clusterId});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\ncockroach = cockroach.PrivateEndpointServices(\"cockroach\", cluster_id=cluster_id)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var cockroach = new Cockroach.PrivateEndpointServices(\"cockroach\", new()\n    {\n        ClusterId = clusterId,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\t_, err := cockroach.NewPrivateEndpointServices(ctx, \"cockroach\", &cockroach.PrivateEndpointServicesArgs{\n\t\t\tClusterId: pulumi.String(clusterId),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.PrivateEndpointServices;\nimport com.pulumi.cockroach.PrivateEndpointServicesArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        var cockroach = new PrivateEndpointServices(\"cockroach\", PrivateEndpointServicesArgs.builder()\n            .clusterId(clusterId)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\nresources:\n  cockroach:\n    type: cockroach:PrivateEndpointServices\n    properties:\n      clusterId: ${clusterId}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>\n\n```sh\n$ pulumi import cockroach:index/privateEndpointServices:PrivateEndpointServices resource_name 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "clusterId": {
          "type": "string"
        },
        "services": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FPrivateEndpointServicesService:PrivateEndpointServicesService"
          }
        },
        "servicesMap": {
          "type": "object",
          "additionalProperties": {
            "$ref": "#/types/cockroach:index%2FPrivateEndpointServicesServicesMap:PrivateEndpointServicesServicesMap"
          },
          "description": "a map of services keyed by the region name\n"
        }
      },
      "type": "object",
      "required": [
        "clusterId",
        "services",
        "servicesMap"
      ],
      "inputProperties": {
        "clusterId": {
          "type": "string"
        }
      },
      "requiredInputs": [
        "clusterId"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering PrivateEndpointServices resources.\n",
        "properties": {
          "clusterId": {
            "type": "string"
          },
          "services": {
            "type": "array",
            "items": {
              "$ref": "#/types/cockroach:index%2FPrivateEndpointServicesService:PrivateEndpointServicesService"
            }
          },
          "servicesMap": {
            "type": "object",
            "additionalProperties": {
              "$ref": "#/types/cockroach:index%2FPrivateEndpointServicesServicesMap:PrivateEndpointServicesServicesMap"
            },
            "description": "a map of services keyed by the region name\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/privateEndpointTrustedOwner:PrivateEndpointTrustedOwner": {
      "description": "Private Endpoint Trusted Owner.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst example = new cockroach.PrivateEndpointTrustedOwner(\"example\", {\n    clusterId: clusterId,\n    type: \"AWS_ACCOUNT_ID\",\n    externalOwnerId: \"012345678901\",\n});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\nexample = cockroach.PrivateEndpointTrustedOwner(\"example\",\n    cluster_id=cluster_id,\n    type=\"AWS_ACCOUNT_ID\",\n    external_owner_id=\"012345678901\")\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var example = new Cockroach.PrivateEndpointTrustedOwner(\"example\", new()\n    {\n        ClusterId = clusterId,\n        Type = \"AWS_ACCOUNT_ID\",\n        ExternalOwnerId = \"012345678901\",\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\t_, err := cockroach.NewPrivateEndpointTrustedOwner(ctx, \"example\", &cockroach.PrivateEndpointTrustedOwnerArgs{\n\t\t\tClusterId:       pulumi.String(clusterId),\n\t\t\tType:            pulumi.String(\"AWS_ACCOUNT_ID\"),\n\t\t\tExternalOwnerId: pulumi.String(\"012345678901\"),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.PrivateEndpointTrustedOwner;\nimport com.pulumi.cockroach.PrivateEndpointTrustedOwnerArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        var example = new PrivateEndpointTrustedOwner(\"example\", PrivateEndpointTrustedOwnerArgs.builder()\n            .clusterId(clusterId)\n            .type(\"AWS_ACCOUNT_ID\")\n            .externalOwnerId(\"012345678901\")\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\nresources:\n  example:\n    type: cockroach:PrivateEndpointTrustedOwner\n    properties:\n      clusterId: ${clusterId}\n      type: AWS_ACCOUNT_ID\n      externalOwnerId: '012345678901'\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>:<owner id>\n\n```sh\n$ pulumi import cockroach:index/privateEndpointTrustedOwner:PrivateEndpointTrustedOwner resource_name 1f69fdd2-600a-4cfc-a9ba-16995df0d77d:e50aa10d-1a16-4be8-85e6-4c18221daa49\n```\n\n",
      "properties": {
        "clusterId": {
          "type": "string",
          "description": "UUID of the cluster the private endpoint trusted owner entry belongs to.\n"
        },
        "externalOwnerId": {
          "type": "string",
          "description": "Owner ID of the private endpoint connection in the cloud provider.\n"
        },
        "ownerId": {
          "type": "string",
          "description": "UUID of the private endpoint trusted owner entry.\n"
        },
        "type": {
          "type": "string",
          "description": "Representation of the external_owner_id field. Allowed values are: * AWS_ACCOUNT_ID\n"
        }
      },
      "type": "object",
      "required": [
        "clusterId",
        "externalOwnerId",
        "ownerId",
        "type"
      ],
      "inputProperties": {
        "clusterId": {
          "type": "string",
          "description": "UUID of the cluster the private endpoint trusted owner entry belongs to.\n"
        },
        "externalOwnerId": {
          "type": "string",
          "description": "Owner ID of the private endpoint connection in the cloud provider.\n"
        },
        "type": {
          "type": "string",
          "description": "Representation of the external_owner_id field. Allowed values are: * AWS_ACCOUNT_ID\n"
        }
      },
      "requiredInputs": [
        "clusterId",
        "externalOwnerId",
        "type"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering PrivateEndpointTrustedOwner resources.\n",
        "properties": {
          "clusterId": {
            "type": "string",
            "description": "UUID of the cluster the private endpoint trusted owner entry belongs to.\n"
          },
          "externalOwnerId": {
            "type": "string",
            "description": "Owner ID of the private endpoint connection in the cloud provider.\n"
          },
          "ownerId": {
            "type": "string",
            "description": "UUID of the private endpoint trusted owner entry.\n"
          },
          "type": {
            "type": "string",
            "description": "Representation of the external_owner_id field. Allowed values are: * AWS_ACCOUNT_ID\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/serviceAccount:ServiceAccount": {
      "description": "CockroachDB Cloud service account. A service account represents a non-person user. By default a service account has no access but it can be accompanied by either a cockroach.UserRoleGrants resource or any number of cockroach.UserRoleGrant resources to grant it roles.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.ServiceAccount;\nimport com.pulumi.cockroach.ServiceAccountArgs;\nimport com.pulumi.cockroach.UserRoleGrants;\nimport com.pulumi.cockroach.UserRoleGrantsArgs;\nimport com.pulumi.cockroach.inputs.UserRoleGrantsRoleArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        var prodSa = new ServiceAccount(\"prodSa\", ServiceAccountArgs.builder()\n            .name(\"Prod cluster SA\")\n            .description(\"A service account used for managing access to the prod cluster\")\n            .build());\n\n        var prodSaUserRoleGrants = new UserRoleGrants(\"prodSaUserRoleGrants\", UserRoleGrantsArgs.builder()\n            .userId(prodSa.id())\n            .roles(UserRoleGrantsRoleArgs.builder()\n                .role_name(\"CLUSTER_ADMIN\")\n                .resource_type(\"CLUSTER\")\n                .resource_id(prod.id())\n                .build())\n            .build());\n\n    }\n}\n```\n```yaml\nresources:\n  prodSa:\n    type: cockroach:ServiceAccount\n    name: prod_sa\n    properties:\n      name: Prod cluster SA\n      description: A service account used for managing access to the prod cluster\n  prodSaUserRoleGrants:\n    type: cockroach:UserRoleGrants\n    name: prod_sa\n    properties:\n      userId: ${prodSa.id}\n      roles:\n        - role_name: CLUSTER_ADMIN\n          resource_type: CLUSTER\n          resource_id: ${prod.id}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat <resource> <service account id>\n\n```sh\n$ pulumi import cockroach:index/serviceAccount:ServiceAccount api_service_account 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "createdAt": {
          "type": "string",
          "description": "Creation time of the service account.\n"
        },
        "creatorName": {
          "type": "string",
          "description": "Name of the creator of the service account.\n"
        },
        "description": {
          "type": "string",
          "description": "Description of the service account.\n"
        },
        "name": {
          "type": "string",
          "description": "Name of the service account.\n"
        }
      },
      "type": "object",
      "required": [
        "createdAt",
        "creatorName",
        "description",
        "name"
      ],
      "inputProperties": {
        "description": {
          "type": "string",
          "description": "Description of the service account.\n"
        },
        "name": {
          "type": "string",
          "description": "Name of the service account.\n"
        }
      },
      "stateInputs": {
        "description": "Input properties used for looking up and filtering ServiceAccount resources.\n",
        "properties": {
          "createdAt": {
            "type": "string",
            "description": "Creation time of the service account.\n"
          },
          "creatorName": {
            "type": "string",
            "description": "Name of the creator of the service account.\n"
          },
          "description": {
            "type": "string",
            "description": "Description of the service account.\n"
          },
          "name": {
            "type": "string",
            "description": "Name of the service account.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/sqlUser:SqlUser": {
      "description": "CockroachDB SQL user.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst sqlUserPassword = config.require(\"sqlUserPassword\");\nconst cockroach = new cockroach.SqlUser(\"cockroach\", {\n    name: \"example-sql-user\",\n    password: sqlUserPassword,\n    clusterId: clusterId,\n});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\nsql_user_password = config.require(\"sqlUserPassword\")\ncockroach = cockroach.SqlUser(\"cockroach\",\n    name=\"example-sql-user\",\n    password=sql_user_password,\n    cluster_id=cluster_id)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var sqlUserPassword = config.Require(\"sqlUserPassword\");\n    var cockroach = new Cockroach.SqlUser(\"cockroach\", new()\n    {\n        Name = \"example-sql-user\",\n        Password = sqlUserPassword,\n        ClusterId = clusterId,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\tsqlUserPassword := cfg.Require(\"sqlUserPassword\")\n\t\t_, err := cockroach.NewSqlUser(ctx, \"cockroach\", &cockroach.SqlUserArgs{\n\t\t\tName:      pulumi.String(\"example-sql-user\"),\n\t\t\tPassword:  pulumi.String(sqlUserPassword),\n\t\t\tClusterId: pulumi.String(clusterId),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.SqlUser;\nimport com.pulumi.cockroach.SqlUserArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        final var sqlUserPassword = config.get(\"sqlUserPassword\");\n        var cockroach = new SqlUser(\"cockroach\", SqlUserArgs.builder()\n            .name(\"example-sql-user\")\n            .password(sqlUserPassword)\n            .clusterId(clusterId)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\n  # Remember that even variables marked sensitive will show up\n  # in the Terraform state file. Always follow best practices\n  # when managing sensitive info.\n  # https://developer.hashicorp.com/terraform/tutorials/configuration-language/sensitive-variables#sensitive-values-in-state\n  sqlUserPassword:\n    type: string\nresources:\n  cockroach:\n    type: cockroach:SqlUser\n    properties:\n      name: example-sql-user\n      password: ${sqlUserPassword}\n      clusterId: ${clusterId}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>:<sql user name>\n\n```sh\n$ pulumi import cockroach:index/sqlUser:SqlUser bill 1f69fdd2-600a-4cfc-a9ba-16995df0d77d:bill\n```\n\n",
      "properties": {
        "clusterId": {
          "type": "string"
        },
        "name": {
          "type": "string",
          "description": "SQL user name.\n"
        },
        "password": {
          "type": "string",
          "secret": true
        }
      },
      "type": "object",
      "required": [
        "clusterId",
        "name"
      ],
      "inputProperties": {
        "clusterId": {
          "type": "string"
        },
        "name": {
          "type": "string",
          "description": "SQL user name.\n"
        },
        "password": {
          "type": "string",
          "secret": true
        }
      },
      "requiredInputs": [
        "clusterId"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering SqlUser resources.\n",
        "properties": {
          "clusterId": {
            "type": "string"
          },
          "name": {
            "type": "string",
            "description": "SQL user name.\n"
          },
          "password": {
            "type": "string",
            "secret": true
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/userRoleGrant:UserRoleGrant": {
      "description": "## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.UserRoleGrant;\nimport com.pulumi.cockroach.UserRoleGrantArgs;\nimport com.pulumi.cockroach.inputs.UserRoleGrantRoleArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var userId = config.get(\"userId\");\n        var adminGrant = new UserRoleGrant(\"adminGrant\", UserRoleGrantArgs.builder()\n            .userId(userId)\n            .role(UserRoleGrantRoleArgs.builder()\n                .role_name(\"CLUSTER_ADMIN\")\n                .resource_type(\"CLUSTER\")\n                .resource_id(example.id())\n                .build())\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  userId:\n    type: string\nresources:\n  adminGrant:\n    type: cockroach:UserRoleGrant\n    name: admin_grant\n    properties:\n      userId: ${userId}\n      role:\n        role_name: CLUSTER_ADMIN\n        resource_type: CLUSTER\n        resource_id: ${example.id}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nCluster and folder level role grants can be imported using:\n\n<user_id>,<role_name>,<resource_type>,<resource_id>\n\n```sh\n$ pulumi import cockroach:index/userRoleGrant:UserRoleGrant admin_grant 1f69fdd2-600a-4cfc-a9ba-16995df0d77d,CLUSTER_ADMIN,CLUSTER,9b9d23fe-3848-40b2-a3c5-d8ccb1c4f831\n```\n\nOrganization level grants can omit the resource_id\n\n```sh\n$ pulumi import cockroach:index/userRoleGrant:UserRoleGrant org_level_grant 1f69fdd2-600a-4cfc-a9ba-16995df0d77d,ORG_ADMIN,ORGANIZATION\n```\n\n",
      "properties": {
        "role": {
          "$ref": "#/types/cockroach:index%2FUserRoleGrantRole:UserRoleGrantRole"
        },
        "userId": {
          "type": "string",
          "description": "ID of the user to grant these roles to.\n"
        }
      },
      "type": "object",
      "required": [
        "role",
        "userId"
      ],
      "inputProperties": {
        "role": {
          "$ref": "#/types/cockroach:index%2FUserRoleGrantRole:UserRoleGrantRole"
        },
        "userId": {
          "type": "string",
          "description": "ID of the user to grant these roles to.\n"
        }
      },
      "requiredInputs": [
        "role",
        "userId"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering UserRoleGrant resources.\n",
        "properties": {
          "role": {
            "$ref": "#/types/cockroach:index%2FUserRoleGrantRole:UserRoleGrantRole"
          },
          "userId": {
            "type": "string",
            "description": "ID of the user to grant these roles to.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/userRoleGrants:UserRoleGrants": {
      "description": "## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.UserRoleGrants;\nimport com.pulumi.cockroach.UserRoleGrantsArgs;\nimport com.pulumi.cockroach.inputs.UserRoleGrantsRoleArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var userId = config.get(\"userId\");\n        var cockroach = new UserRoleGrants(\"cockroach\", UserRoleGrantsArgs.builder()\n            .userId(userId)\n            .roles(            \n                UserRoleGrantsRoleArgs.builder()\n                    .role_name(\"ORG_MEMBER\")\n                    .resource_type(\"ORGANIZATION\")\n                    .resource_id(\"\")\n                    .build(),\n                UserRoleGrantsRoleArgs.builder()\n                    .role_name(\"ORG_ADMIN\")\n                    .resource_type(\"ORGANIZATION\")\n                    .resource_id(\"\")\n                    .build(),\n                UserRoleGrantsRoleArgs.builder()\n                    .role_name(\"CLUSTER_ADMIN\")\n                    .resource_type(\"CLUSTER\")\n                    .resource_id(prod.id())\n                    .build(),\n                UserRoleGrantsRoleArgs.builder()\n                    .role_name(\"FOLDER_ADMIN\")\n                    .resource_type(\"FOLDER\")\n                    .resource_id(dev.id())\n                    .build())\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  userId:\n    type: string\nresources:\n  cockroach:\n    type: cockroach:UserRoleGrants\n    properties:\n      userId: ${userId}\n      roles:\n        - role_name: ORG_MEMBER\n          resource_type: ORGANIZATION\n          resource_id: \"\"\n        - role_name: ORG_ADMIN\n          resource_type: ORGANIZATION\n          resource_id: \"\"\n        - role_name: CLUSTER_ADMIN\n          resource_type: CLUSTER\n          resource_id: ${prod.id}\n        - role_name: FOLDER_ADMIN\n          resource_type: FOLDER\n          resource_id: ${dev.id}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <user id>\n\n```sh\n$ pulumi import cockroach:index/userRoleGrants:UserRoleGrants service_account 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "roles": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FUserRoleGrantsRole:UserRoleGrantsRole"
          },
          "description": "The list of roles to include. ORG_MEMBER must be included.\n"
        },
        "userId": {
          "type": "string",
          "description": "ID of the user to grant these roles to.\n"
        }
      },
      "type": "object",
      "required": [
        "roles",
        "userId"
      ],
      "inputProperties": {
        "roles": {
          "type": "array",
          "items": {
            "$ref": "#/types/cockroach:index%2FUserRoleGrantsRole:UserRoleGrantsRole"
          },
          "description": "The list of roles to include. ORG_MEMBER must be included.\n"
        },
        "userId": {
          "type": "string",
          "description": "ID of the user to grant these roles to.\n"
        }
      },
      "requiredInputs": [
        "roles",
        "userId"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering UserRoleGrants resources.\n",
        "properties": {
          "roles": {
            "type": "array",
            "items": {
              "$ref": "#/types/cockroach:index%2FUserRoleGrantsRole:UserRoleGrantsRole"
            },
            "description": "The list of roles to include. ORG_MEMBER must be included.\n"
          },
          "userId": {
            "type": "string",
            "description": "ID of the user to grant these roles to.\n"
          }
        },
        "type": "object"
      }
    },
    "cockroach:index/versionDeferral:VersionDeferral": {
      "description": "Configure minor version upgrade deferral for a cluster.\n\n## Example Usage\n\n<!--Start PulumiCodeChooser -->\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumiverse/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst offsetDuration = config.get(\"offsetDuration\") || \"FIXED_DEFERRAL\";\nconst example = new cockroach.VersionDeferral(\"example\", {\n    clusterId: clusterId,\n    deferralPolicy: offsetDuration,\n});\n```\n```python\nimport pulumi\nimport pulumiverse_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\noffset_duration = config.get(\"offsetDuration\")\nif offset_duration is None:\n    offset_duration = \"FIXED_DEFERRAL\"\nexample = cockroach.VersionDeferral(\"example\",\n    cluster_id=cluster_id,\n    deferral_policy=offset_duration)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumiverse.Cockroach;\n\nreturn await Deployment.RunAsync(() => \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var offsetDuration = config.Get(\"offsetDuration\") ?? \"FIXED_DEFERRAL\";\n    var example = new Cockroach.VersionDeferral(\"example\", new()\n    {\n        ClusterId = clusterId,\n        DeferralPolicy = offsetDuration,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\toffsetDuration := \"FIXED_DEFERRAL\"\n\t\tif param := cfg.Get(\"offsetDuration\"); param != \"\" {\n\t\t\toffsetDuration = param\n\t\t}\n\t\t_, err := cockroach.NewVersionDeferral(ctx, \"example\", &cockroach.VersionDeferralArgs{\n\t\t\tClusterId:      pulumi.String(clusterId),\n\t\t\tDeferralPolicy: pulumi.String(offsetDuration),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.VersionDeferral;\nimport com.pulumi.cockroach.VersionDeferralArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        final var offsetDuration = config.get(\"offsetDuration\").orElse(\"FIXED_DEFERRAL\");\n        var example = new VersionDeferral(\"example\", VersionDeferralArgs.builder()\n            .clusterId(clusterId)\n            .deferralPolicy(offsetDuration)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\n  offsetDuration:\n    type: string\n    default: FIXED_DEFERRAL\nresources:\n  example:\n    type: cockroach:VersionDeferral\n    properties:\n      clusterId: ${clusterId}\n      deferralPolicy: ${offsetDuration}\n```\n<!--End PulumiCodeChooser -->\n\n## Import\n\nformat: <cluster id>\n\n```sh\n$ pulumi import cockroach:index/versionDeferral:VersionDeferral example 1f69fdd2-600a-4cfc-a9ba-16995df0d77d\n```\n\n",
      "properties": {
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "deferralPolicy": {
          "type": "string",
          "description": "The policy for managing automated minor version upgrades. Set to FIXED*DEFERRAL to defer upgrades by 60 days or NOT*DEFERRED to apply upgrades immediately.\n"
        }
      },
      "type": "object",
      "required": [
        "clusterId",
        "deferralPolicy"
      ],
      "inputProperties": {
        "clusterId": {
          "type": "string",
          "description": "Cluster ID.\n"
        },
        "deferralPolicy": {
          "type": "string",
          "description": "The policy for managing automated minor version upgrades. Set to FIXED*DEFERRAL to defer upgrades by 60 days or NOT*DEFERRED to apply upgrades immediately.\n"
        }
      },
      "requiredInputs": [
        "clusterId",
        "deferralPolicy"
      ],
      "stateInputs": {
        "description": "Input properties used for looking up and filtering VersionDeferral resources.\n",
        "properties": {
          "clusterId": {
            "type": "string",
            "description": "Cluster ID.\n"
          },
          "deferralPolicy": {
            "type": "string",
            "description": "The policy for managing automated minor version upgrades. Set to FIXED*DEFERRAL to defer upgrades by 60 days or NOT*DEFERRED to apply upgrades immediately.\n"
          }
        },
        "type": "object"
      }
    }
  },
  "functions": {
    "cockroach:index/getClusterCert:getClusterCert": {
      "description": "TLS certificate for the specified CockroachDB cluster. Certificates for dedicated clusters should be written to `$HOME/Library/CockroachCloud/certs/\u003ccluster name\u003e-ca.crt` on MacOS or Linux, or `$env:appdata\\CockroachCloud\\certs\\\u003ccluster name\u003e-ca.crt` on Windows. \n\nServerless clusters use the root PostgreSQL CA cert. If it isn't already installed, the certificate can be appended to `$HOME/.postgresql/root.crt` on MacOS or Linux, or `$env:appdata\\postgresql\\root.crt` on Windows.\n\n## Example Usage\n\n\u003c!--Start PulumiCodeChooser --\u003e\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumi/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst cockroach = cockroach.getClusterCert({\n    id: clusterId,\n});\n```\n```python\nimport pulumi\nimport pulumi_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\ncockroach = cockroach.get_cluster_cert(id=cluster_id)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumi.Cockroach;\n\nreturn await Deployment.RunAsync(() =\u003e \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var cockroach = Cockroach.GetClusterCert.Invoke(new()\n    {\n        Id = clusterId,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\t_, err := cockroach.GetClusterCert(ctx, \u0026cockroach.GetClusterCertArgs{\n\t\t\tId: clusterId,\n\t\t}, nil)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.CockroachFunctions;\nimport com.pulumi.cockroach.inputs.GetClusterCertArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        final var cockroach = CockroachFunctions.getClusterCert(GetClusterCertArgs.builder()\n            .id(clusterId)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\nvariables:\n  cockroach:\n    fn::invoke:\n      function: cockroach:getClusterCert\n      arguments:\n        id: ${clusterId}\n```\n\u003c!--End PulumiCodeChooser --\u003e\n",
      "inputs": {
        "description": "A collection of arguments for invoking getClusterCert.\n",
        "properties": {
          "id": {
            "type": "string",
            "description": "Cluster ID.\n"
          }
        },
        "type": "object",
        "required": [
          "id"
        ]
      },
      "outputs": {
        "description": "A collection of values returned by getClusterCert.\n",
        "properties": {
          "cert": {
            "description": "Certificate contents.\n",
            "type": "string"
          },
          "id": {
            "description": "Cluster ID.\n",
            "type": "string"
          }
        },
        "required": [
          "cert",
          "id"
        ],
        "type": "object"
      }
    },
    "cockroach:index/getCockroachCluster:getCockroachCluster": {
      "description": "CockroachDB Cloud cluster. Can be Dedicated or Serverless.\n\n## Example Usage\n\n\u003c!--Start PulumiCodeChooser --\u003e\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumi/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst cockroach = cockroach.getCockroachCluster({\n    id: clusterId,\n});\n```\n```python\nimport pulumi\nimport pulumi_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\ncockroach = cockroach.get_cockroach_cluster(id=cluster_id)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumi.Cockroach;\n\nreturn await Deployment.RunAsync(() =\u003e \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var cockroach = Cockroach.GetCockroachCluster.Invoke(new()\n    {\n        Id = clusterId,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\t_, err := cockroach.GetCockroachCluster(ctx, \u0026cockroach.GetCockroachClusterArgs{\n\t\t\tId: clusterId,\n\t\t}, nil)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.CockroachFunctions;\nimport com.pulumi.cockroach.inputs.GetCockroachClusterArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        final var cockroach = CockroachFunctions.getCockroachCluster(GetCockroachClusterArgs.builder()\n            .id(clusterId)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\nvariables:\n  cockroach:\n    fn::invoke:\n      function: cockroach:getCockroachCluster\n      arguments:\n        id: ${clusterId}\n```\n\u003c!--End PulumiCodeChooser --\u003e\n",
      "inputs": {
        "description": "A collection of arguments for invoking getCockroachCluster.\n",
        "properties": {
          "id": {
            "type": "string"
          }
        },
        "type": "object",
        "required": [
          "id"
        ]
      },
      "outputs": {
        "description": "A collection of values returned by getCockroachCluster.\n",
        "properties": {
          "accountId": {
            "type": "string"
          },
          "backupConfig": {
            "$ref": "#/types/cockroach:index%2FgetCockroachClusterBackupConfig:getCockroachClusterBackupConfig"
          },
          "cloudProvider": {
            "type": "string"
          },
          "cockroachVersion": {
            "type": "string"
          },
          "creatorId": {
            "type": "string"
          },
          "dedicated": {
            "$ref": "#/types/cockroach:index%2FgetCockroachClusterDedicated:getCockroachClusterDedicated"
          },
          "deleteProtection": {
            "type": "boolean"
          },
          "id": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "operationStatus": {
            "type": "string"
          },
          "parentId": {
            "type": "string"
          },
          "plan": {
            "type": "string"
          },
          "regions": {
            "items": {
              "$ref": "#/types/cockroach:index%2FgetCockroachClusterRegion:getCockroachClusterRegion"
            },
            "type": "array"
          },
          "serverless": {
            "$ref": "#/types/cockroach:index%2FgetCockroachClusterServerless:getCockroachClusterServerless"
          },
          "state": {
            "type": "string"
          },
          "upgradeStatus": {
            "type": "string"
          }
        },
        "required": [
          "accountId",
          "backupConfig",
          "cloudProvider",
          "cockroachVersion",
          "creatorId",
          "dedicated",
          "deleteProtection",
          "id",
          "name",
          "operationStatus",
          "parentId",
          "plan",
          "regions",
          "serverless",
          "state",
          "upgradeStatus"
        ],
        "type": "object"
      }
    },
    "cockroach:index/getConnectionString:getConnectionString": {
      "description": "Generic connection string for a cluster.\n\n## Example Usage\n\n\u003c!--Start PulumiCodeChooser --\u003e\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumi/cockroach\";\n\nconst config = new pulumi.Config();\nconst clusterId = config.require(\"clusterId\");\nconst sqlUserName = config.require(\"sqlUserName\");\nconst sqlUserPassword = config.require(\"sqlUserPassword\");\nconst database = config.require(\"database\");\nconst os = config.require(\"os\");\nconst cockroach = cockroach.getConnectionString({\n    id: clusterId,\n    sqlUser: sqlUserName,\n    password: sqlUserPassword,\n    database: database,\n    os: os,\n});\n```\n```python\nimport pulumi\nimport pulumi_cockroach as cockroach\n\nconfig = pulumi.Config()\ncluster_id = config.require(\"clusterId\")\nsql_user_name = config.require(\"sqlUserName\")\nsql_user_password = config.require(\"sqlUserPassword\")\ndatabase = config.require(\"database\")\nos = config.require(\"os\")\ncockroach = cockroach.get_connection_string(id=cluster_id,\n    sql_user=sql_user_name,\n    password=sql_user_password,\n    database=database,\n    os=os)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumi.Cockroach;\n\nreturn await Deployment.RunAsync(() =\u003e \n{\n    var config = new Config();\n    var clusterId = config.Require(\"clusterId\");\n    var sqlUserName = config.Require(\"sqlUserName\");\n    var sqlUserPassword = config.Require(\"sqlUserPassword\");\n    var database = config.Require(\"database\");\n    var os = config.Require(\"os\");\n    var cockroach = Cockroach.GetConnectionString.Invoke(new()\n    {\n        Id = clusterId,\n        SqlUser = sqlUserName,\n        Password = sqlUserPassword,\n        Database = database,\n        Os = os,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tclusterId := cfg.Require(\"clusterId\")\n\t\tsqlUserName := cfg.Require(\"sqlUserName\")\n\t\tsqlUserPassword := cfg.Require(\"sqlUserPassword\")\n\t\tdatabase := cfg.Require(\"database\")\n\t\tos := cfg.Require(\"os\")\n\t\t_, err := cockroach.GetConnectionString(ctx, \u0026cockroach.GetConnectionStringArgs{\n\t\t\tId:       clusterId,\n\t\t\tSqlUser:  pulumi.StringRef(sqlUserName),\n\t\t\tPassword: pulumi.StringRef(sqlUserPassword),\n\t\t\tDatabase: pulumi.StringRef(database),\n\t\t\tOs:       pulumi.StringRef(os),\n\t\t}, nil)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.CockroachFunctions;\nimport com.pulumi.cockroach.inputs.GetConnectionStringArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var clusterId = config.get(\"clusterId\");\n        final var sqlUserName = config.get(\"sqlUserName\");\n        final var sqlUserPassword = config.get(\"sqlUserPassword\");\n        final var database = config.get(\"database\");\n        final var os = config.get(\"os\");\n        final var cockroach = CockroachFunctions.getConnectionString(GetConnectionStringArgs.builder()\n            .id(clusterId)\n            .sqlUser(sqlUserName)\n            .password(sqlUserPassword)\n            .database(database)\n            .os(os)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  clusterId:\n    type: string\n  sqlUserName:\n    type: string\n  sqlUserPassword:\n    type: string\n  database:\n    type: string\n  os:\n    type: string\nvariables:\n  cockroach:\n    fn::invoke:\n      function: cockroach:getConnectionString\n      arguments:\n        id: ${clusterId}\n        sqlUser: ${sqlUserName}\n        password: ${sqlUserPassword}\n        database: ${database}\n        os: ${os}\n```\n\u003c!--End PulumiCodeChooser --\u003e\n",
      "inputs": {
        "description": "A collection of arguments for invoking getConnectionString.\n",
        "properties": {
          "database": {
            "type": "string"
          },
          "id": {
            "type": "string"
          },
          "os": {
            "type": "string"
          },
          "password": {
            "type": "string",
            "secret": true
          },
          "sqlUser": {
            "type": "string"
          }
        },
        "type": "object",
        "required": [
          "id"
        ]
      },
      "outputs": {
        "description": "A collection of values returned by getConnectionString.\n",
        "properties": {
          "connectionParams": {
            "$ref": "#/types/cockroach:index%2FgetConnectionStringConnectionParams:getConnectionStringConnectionParams"
          },
          "connectionString": {
            "type": "string"
          },
          "database": {
            "type": "string"
          },
          "id": {
            "type": "string"
          },
          "os": {
            "type": "string"
          },
          "password": {
            "secret": true,
            "type": "string"
          },
          "sqlUser": {
            "type": "string"
          }
        },
        "required": [
          "connectionParams",
          "connectionString",
          "database",
          "id",
          "os"
        ],
        "type": "object"
      }
    },
    "cockroach:index/getFolder:getFolder": {
      "description": "A CockroachDB Cloud folder. Folders can contain clusters or other folders.  They can be used to group resources together for the purposes of access control, organization or fine grained invoicing.\n\n## Example Usage\n\n\u003c!--Start PulumiCodeChooser --\u003e\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumi/cockroach\";\n\nconst config = new pulumi.Config();\nconst prodFolderId = config.require(\"prodFolderId\");\nconst team1 = cockroach.getFolder({\n    path: \"/prod/team1\",\n});\nconst prod = cockroach.getFolder({\n    id: prodFolderId,\n});\n```\n```python\nimport pulumi\nimport pulumi_cockroach as cockroach\n\nconfig = pulumi.Config()\nprod_folder_id = config.require(\"prodFolderId\")\nteam1 = cockroach.get_folder(path=\"/prod/team1\")\nprod = cockroach.get_folder(id=prod_folder_id)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumi.Cockroach;\n\nreturn await Deployment.RunAsync(() =\u003e \n{\n    var config = new Config();\n    var prodFolderId = config.Require(\"prodFolderId\");\n    var team1 = Cockroach.GetFolder.Invoke(new()\n    {\n        Path = \"/prod/team1\",\n    });\n\n    var prod = Cockroach.GetFolder.Invoke(new()\n    {\n        Id = prodFolderId,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\tprodFolderId := cfg.Require(\"prodFolderId\")\n\t\t_, err := cockroach.LookupFolder(ctx, \u0026cockroach.LookupFolderArgs{\n\t\t\tPath: pulumi.StringRef(\"/prod/team1\"),\n\t\t}, nil)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\t_, err = cockroach.LookupFolder(ctx, \u0026cockroach.LookupFolderArgs{\n\t\t\tId: pulumi.StringRef(prodFolderId),\n\t\t}, nil)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.CockroachFunctions;\nimport com.pulumi.cockroach.inputs.GetFolderArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var prodFolderId = config.get(\"prodFolderId\");\n        final var team1 = CockroachFunctions.getFolder(GetFolderArgs.builder()\n            .path(\"/prod/team1\")\n            .build());\n\n        final var prod = CockroachFunctions.getFolder(GetFolderArgs.builder()\n            .id(prodFolderId)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  prodFolderId:\n    type: string\nvariables:\n  team1:\n    fn::invoke:\n      function: cockroach:getFolder\n      arguments:\n        path: /prod/team1\n  prod:\n    fn::invoke:\n      function: cockroach:getFolder\n      arguments:\n        id: ${prodFolderId}\n```\n\u003c!--End PulumiCodeChooser --\u003e\n",
      "inputs": {
        "description": "A collection of arguments for invoking getFolder.\n",
        "properties": {
          "id": {
            "type": "string",
            "description": "The id the folder.\n"
          },
          "path": {
            "type": "string",
            "description": "An absolute path to the folder. Trailing slashes are optional. (i.e. /folder1/folder2)\n"
          }
        },
        "type": "object"
      },
      "outputs": {
        "description": "A collection of values returned by getFolder.\n",
        "properties": {
          "id": {
            "description": "The id the folder.\n",
            "type": "string"
          },
          "name": {
            "description": "Name of the folder.\n",
            "type": "string"
          },
          "parentId": {
            "description": "The ID of the folders's parent folder. 'root' is used for a folder at the root level.\n",
            "type": "string"
          },
          "path": {
            "description": "An absolute path to the folder. Trailing slashes are optional. (i.e. /folder1/folder2)\n",
            "type": "string"
          }
        },
        "required": [
          "name",
          "parentId"
        ],
        "type": "object"
      }
    },
    "cockroach:index/getOrganization:getOrganization": {
      "description": "Information about the organization associated with the user's API key.\n\n## Example Usage\n\n\u003c!--Start PulumiCodeChooser --\u003e\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumi/cockroach\";\n\nconst prod = cockroach.getOrganization({});\n```\n```python\nimport pulumi\nimport pulumi_cockroach as cockroach\n\nprod = cockroach.get_organization()\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumi.Cockroach;\n\nreturn await Deployment.RunAsync(() =\u003e \n{\n    var prod = Cockroach.GetOrganization.Invoke();\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\t_, err := cockroach.GetOrganization(ctx, map[string]interface{}{}, nil)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.CockroachFunctions;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var prod = CockroachFunctions.getOrganization();\n\n    }\n}\n```\n```yaml\nvariables:\n  prod:\n    fn::invoke:\n      function: cockroach:getOrganization\n      arguments: {}\n```\n\u003c!--End PulumiCodeChooser --\u003e\n",
      "outputs": {
        "description": "A collection of values returned by getOrganization.\n",
        "properties": {
          "createdAt": {
            "description": "Indicates when the organization was created.\n",
            "type": "string"
          },
          "id": {
            "description": "Organization ID.\n",
            "type": "string"
          },
          "label": {
            "description": "A short ID used by CockroachDB Support.\n",
            "type": "string"
          },
          "name": {
            "description": "Name of the organization.\n",
            "type": "string"
          }
        },
        "required": [
          "createdAt",
          "id",
          "label",
          "name"
        ],
        "type": "object"
      }
    },
    "cockroach:index/getPersonUser:getPersonUser": {
      "description": "Information about an individual user.\n\n## Example Usage\n\n\u003c!--Start PulumiCodeChooser --\u003e\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as cockroach from \"@pulumi/cockroach\";\n\nconst config = new pulumi.Config();\nconst emailAddress = config.require(\"emailAddress\");\nconst cockroach = cockroach.getPersonUser({\n    email: emailAddress,\n});\n```\n```python\nimport pulumi\nimport pulumi_cockroach as cockroach\n\nconfig = pulumi.Config()\nemail_address = config.require(\"emailAddress\")\ncockroach = cockroach.get_person_user(email=email_address)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Cockroach = Pulumi.Cockroach;\n\nreturn await Deployment.RunAsync(() =\u003e \n{\n    var config = new Config();\n    var emailAddress = config.Require(\"emailAddress\");\n    var cockroach = Cockroach.GetPersonUser.Invoke(new()\n    {\n        Email = emailAddress,\n    });\n\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config\"\n\t\"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\tcfg := config.New(ctx, \"\")\n\t\temailAddress := cfg.Require(\"emailAddress\")\n\t\t_, err := cockroach.GetPersonUser(ctx, \u0026cockroach.GetPersonUserArgs{\n\t\t\tEmail: emailAddress,\n\t\t}, nil)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.cockroach.CockroachFunctions;\nimport com.pulumi.cockroach.inputs.GetPersonUserArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n    public static void main(String[] args) {\n        Pulumi.run(App::stack);\n    }\n\n    public static void stack(Context ctx) {\n        final var config = ctx.config();\n        final var emailAddress = config.get(\"emailAddress\");\n        final var cockroach = CockroachFunctions.getPersonUser(GetPersonUserArgs.builder()\n            .email(emailAddress)\n            .build());\n\n    }\n}\n```\n```yaml\nconfiguration:\n  emailAddress:\n    type: string\nvariables:\n  cockroach:\n    fn::invoke:\n      function: cockroach:getPersonUser\n      arguments:\n        email: ${emailAddress}\n```\n\u003c!--End PulumiCodeChooser --\u003e\n",
      "inputs": {
        "description": "A collection of arguments for invoking getPersonUser.\n",
        "properties": {
          "email": {
            "type": "string",
            "description": "Email address used to find the User ID.\n"
          }
        },
        "type": "object",
        "required": [
          "email"
        ]
      },
      "outputs": {
        "description": "A collection of values returned by getPersonUser.\n",
        "properties": {
          "email": {
            "description": "Email address used to find the User ID.\n",
            "type": "string"
          },
          "id": {
            "description": "User ID.\n",
            "type": "string"
          }
        },
        "required": [
          "email",
          "id"
        ],
        "type": "object"
      }
    }
  }
}