pulumi-bunnynet 0.6.2

package/README.md

@@ -0,0 +1,348 @@
+# Pulumi Bunnynet Provider
+
+A Pulumi provider for managing Bunny.net CDN and edge computing resources, dynamically bridged from the [Terraform Bunnynet Provider](https://github.com/bunnyway/terraform-provider-bunnynet).
+
+## Introduction
+
+This package provides a Pulumi provider that enables you to manage your Bunny.net CDN, storage, DNS, compute containers, and video streaming resources using TypeScript, JavaScript, Python, Go, or C#. The provider is automatically generated from the Terraform Bunnynet provider, giving you access to all its functionality within the Pulumi ecosystem.
+
+### Features
+
+- **Pull Zones (CDN)**: Create and manage CDN pull zones with edge rules, hostnames, and optimizer classes
+- **Storage Management**: Manage storage zones and files for global content delivery
+- **DNS Management**: Configure DNS zones and records for your domains
+- **Compute Containers**: Deploy and manage container applications at the edge
+- **Video Streaming**: Set up video libraries, collections, and streaming content
+- **Edge Computing**: Configure compute scripts with variables and secrets
+- **TypeScript Support**: Full type safety with comprehensive TypeScript definitions
+
+## Installation
+
+### npm
+
+```bash
+npm install pulumi-bunnynet
+```
+
+### yarn
+
+```bash
+yarn add pulumi-bunnynet
+```
+
+### pnpm
+
+```bash
+pnpm add pulumi-bunnynet
+```
+
+## Configuration
+
+Before using the provider, you need to configure authentication with your Bunny.net API credentials.
+
+### Required Configuration
+
+- **API Key**: Your Bunny.net API key
+- **Access Key**: Your storage access key (for storage operations)
+
+### Setting Configuration
+
+You can configure the provider in several ways:
+
+#### 1. Using Pulumi Config
+
+```bash
+pulumi config set bunnynet:apiKey your-api-key
+pulumi config set bunnynet:accessKey your-access-key
+```
+
+#### 2. Using Environment Variables
+
+```bash
+export BUNNYNET_API_KEY="your-api-key"
+export BUNNYNET_ACCESS_KEY="your-access-key"
+```
+
+#### 3. Provider Constructor
+
+```typescript
+import * as bunnynet from 'pulumi-bunnynet'
+
+const provider = new bunnynet.Provider('bunnynet-provider', {
+  apiKey: 'your-api-key',
+  accessKey: 'your-access-key',
+})
+```
+
+## Usage
+
+### Pull Zone Management
+
+```typescript
+import * as bunnynet from 'pulumi-bunnynet'
+
+// Create a pull zone for CDN
+const pullZone = new bunnynet.Pullzone('my-cdn', {
+  name: 'my-website-cdn',
+  originUrl: 'https://my-website.com',
+  type: 'standard',
+  storageZoneId: 12345,
+  cacheControlMaxAge: 3600,
+  cacheControlPublicMaxAge: 86400,
+  addCanonicalHeader: true,
+  enableGeoipCountryCode: true,
+  enableOriginShield: true,
+})
+
+// Add a custom hostname
+const hostname = new bunnynet.PullzoneHostname('custom-domain', {
+  pullzoneId: pullZone.id,
+  hostname: 'cdn.my-website.com',
+  certificateId: 67890,
+})
+
+// Create edge rules
+const edgeRule = new bunnynet.PullzoneEdgerule('cache-rule', {
+  pullzoneId: pullZone.id,
+  actionType: 'SetCacheTime',
+  triggerType: 'RequestHeader',
+  triggerValue: 'X-Cache-Control',
+  actionParameter1: '3600',
+})
+```
+
+### Storage Management
+
+```typescript
+import * as bunnynet from 'pulumi-bunnynet'
+
+// Create a storage zone
+const storageZone = new bunnynet.StorageZone('media-storage', {
+  name: 'media-files',
+  region: 'NY', // New York region
+  replicationRegions: ['LA', 'SG'], // Los Angeles and Singapore replicas
+})
+
+// Upload files to storage
+const file = new bunnynet.StorageFile('logo', {
+  storageZoneName: storageZone.name,
+  path: '/images/logo.png',
+  source: './assets/logo.png',
+  contentType: 'image/png',
+})
+```
+
+### DNS Management
+
+```typescript
+import * as bunnynet from 'pulumi-bunnynet'
+
+// Create DNS zone
+const dnsZone = new bunnynet.DnsZone('my-domain', {
+  domain: 'example.com',
+  soaEmail: 'admin@example.com',
+})
+
+// Add DNS records
+const aRecord = new bunnynet.DnsRecord('www-record', {
+  zoneId: dnsZone.id,
+  type: 'A',
+  name: 'www',
+  value: '203.0.113.1',
+  ttl: 3600,
+})
+
+const cnameRecord = new bunnynet.DnsRecord('cdn-record', {
+  zoneId: dnsZone.id,
+  type: 'CNAME',
+  name: 'cdn',
+  value: 'b-cdn.net',
+  ttl: 3600,
+})
+```
+
+### Compute Container Applications
+
+```typescript
+import * as bunnynet from 'pulumi-bunnynet'
+
+// Create container image registry
+const registry = new bunnynet.ComputeContainerImageregistry('my-registry', {
+  name: 'my-app-registry',
+  imageUrl: 'docker.io/myorg/myapp:latest',
+  username: 'myusername',
+  password: 'mypassword',
+})
+
+// Deploy container app
+const containerApp = new bunnynet.ComputeContainerApp('edge-app', {
+  name: 'my-edge-app',
+  imageRegistryId: registry.id,
+  environmentVariables: [
+    {
+      name: 'NODE_ENV',
+      value: 'production',
+    },
+    {
+      name: 'API_URL',
+      value: 'https://api.example.com',
+    },
+  ],
+  cpu: 0.1,
+  memory: 128,
+})
+```
+
+### Video Streaming
+
+```typescript
+import * as bunnynet from 'pulumi-bunnynet'
+
+// Create video library
+const videoLibrary = new bunnynet.StreamLibrary('video-content', {
+  name: 'my-video-library',
+  storageZoneId: 12345,
+  replicationRegions: ['NY', 'LA', 'SG'],
+  watermarkPositionLeft: 10,
+  watermarkPositionTop: 10,
+  watermarkWidth: 100,
+  watermarkHeight: 50,
+})
+
+// Create video collection
+const collection = new bunnynet.StreamCollection('tutorials', {
+  libraryId: videoLibrary.id,
+  name: 'Tutorial Videos',
+})
+
+// Upload video
+const video = new bunnynet.StreamVideo('intro-video', {
+  libraryId: videoLibrary.id,
+  title: 'Introduction Tutorial',
+  collectionId: collection.id,
+  // Video will be uploaded separately via API or dashboard
+})
+```
+
+### Compute Scripts
+
+```typescript
+import * as bunnynet from 'pulumi-bunnynet'
+
+// Create compute script
+const script = new bunnynet.ComputeScript('edge-function', {
+  name: 'my-edge-function',
+  scriptType: 'standalone',
+  code: `
+        async function handleRequest(request) {
+            const response = await fetch(request);
+            const body = await response.text();
+            
+            // Add custom header
+            const headers = new Headers(response.headers);
+            headers.set('X-Processed-By', 'Bunny-Edge');
+            
+            return new Response(body, {
+                status: response.status,
+                headers: headers
+            });
+        }
+        
+        addEventListener('fetch', event => {
+            event.respondWith(handleRequest(event.request));
+        });
+    `,
+})
+
+// Add script variables
+const scriptVar = new bunnynet.ComputeScriptVariable('api-endpoint', {
+  scriptId: script.id,
+  name: 'API_ENDPOINT',
+  value: 'https://api.example.com/v1',
+})
+
+// Add script secrets
+const scriptSecret = new bunnynet.ComputeScriptSecret('api-key', {
+  scriptId: script.id,
+  name: 'API_KEY',
+  value: 'secret-api-key-value',
+})
+```
+
+## Resources
+
+### Pull Zones
+
+- **Pullzone**: Main CDN pull zone configuration
+- **PullzoneHostname**: Custom domains for pull zones
+- **PullzoneEdgerule**: Cache and routing rules
+- **PullzoneOptimizerClass**: Image optimization settings
+
+### Storage
+
+- **StorageZone**: Global storage zones
+- **StorageFile**: Individual file management
+
+### DNS
+
+- **DnsZone**: DNS zone management
+- **DnsRecord**: Individual DNS records (A, AAAA, CNAME, MX, TXT, etc.)
+
+### Compute
+
+- **ComputeContainerApp**: Edge container applications
+- **ComputeContainerImageregistry**: Container image registries
+- **ComputeScript**: Edge computing scripts
+- **ComputeScriptVariable**: Script environment variables
+- **ComputeScriptSecret**: Script secrets
+
+### Video Streaming
+
+- **StreamLibrary**: Video libraries
+- **StreamCollection**: Video collections
+- **StreamVideo**: Individual videos
+
+## API Reference
+
+For detailed API documentation, see the generated documentation in your IDE or visit the [Pulumi Registry](https://www.pulumi.com/registry/).
+
+## Authentication Setup
+
+### Getting Your API Credentials
+
+1. **Log in to Bunny.net**: Go to your Bunny.net dashboard
+2. **Navigate to Account Settings**: Click on your profile → Account Settings
+3. **Generate API Key**: Go to API section and create a new API key
+4. **Storage Access Key**: For storage operations, get your access key from Storage → FTP & API Access
+5. **Note Your Details**: Save your API key and access key securely
+
+### Testing Your Setup
+
+```typescript
+import * as bunnynet from 'pulumi-bunnynet'
+
+// Test with a simple resource query
+const regions = bunnynet.getRegion({})
+```
+
+## Examples
+
+You can find more examples in the [examples directory](./examples) or check out these common use cases:
+
+- [Basic CDN Setup](./examples/basic-cdn)
+- [Storage and File Management](./examples/storage-management)
+- [DNS Configuration](./examples/dns-setup)
+- [Edge Computing](./examples/edge-computing)
+- [Video Streaming Platform](./examples/video-streaming)
+
+## Support
+
+This provider is a derived work of the [Terraform Provider](https://github.com/bunnyway/terraform-provider-bunnynet) distributed under [MPL 2.0](https://www.mozilla.org/en-US/MPL/2.0/).
+
+If you encounter a bug or missing feature, please consult the source [`terraform-provider-bunnynet` repo](https://github.com/bunnyway/terraform-provider-bunnynet/issues).
+
+For Pulumi-specific issues, please open an issue in the [pulumi-any-terraform repository](https://github.com/hckhanh/pulumi-any-terraform).
+
+## License
+
+This package is distributed under the MIT License. The underlying Terraform provider is distributed under MPL 2.0.

package/bin/_virtual/rolldown_runtime.mjs

@@ -0,0 +1,37 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function() {
+	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+export { __commonJS, __esm, __export, __reExport, __toESM };

package/bin/computeContainerApp.d.mts

@@ -0,0 +1,128 @@
+import { ComputeContainerAppContainer } from "./types/input.mjs";
+import { ComputeContainerAppContainer as ComputeContainerAppContainer$1 } from "./types/output.mjs";
+import * as pulumi from "@pulumi/pulumi";
+
+//#region computeContainerApp.d.ts
+declare class ComputeContainerApp extends pulumi.CustomResource {
+  /**
+   * Get an existing ComputeContainerApp resource's state with the given name, ID, and optional extra
+   * properties used to qualify the lookup.
+   *
+   * @param name The _unique_ name of the resulting resource.
+   * @param id The _unique_ provider ID of the resource to lookup.
+   * @param state Any extra arguments used during the lookup.
+   * @param opts Optional settings to control the behavior of the CustomResource.
+   */
+  static get(name: string, id: pulumi.Input<pulumi.ID>, state?: ComputeContainerAppState, opts?: pulumi.CustomResourceOptions): ComputeContainerApp;
+  /** @internal */
+  static readonly __pulumiType: string;
+  /**
+   * Returns true if the given object is an instance of ComputeContainerApp.  This is designed to work even
+   * when multiple copies of the Pulumi SDK have been loaded into the same process.
+   */
+  static isInstance(obj: any): obj is ComputeContainerApp;
+  /**
+   * The maximum number of instances that will be provisioned per active region.
+   */
+  readonly autoscalingMax!: pulumi.Output<number>;
+  /**
+   * The minimum number of instances that will be provisioned per active region.
+   */
+  readonly autoscalingMin!: pulumi.Output<number>;
+  /**
+   * Defines a container for the application.
+   */
+  readonly containers!: pulumi.Output<ComputeContainerAppContainer$1[] | undefined>;
+  /**
+   * The name of the application.
+   */
+  readonly name!: pulumi.Output<string>;
+  /**
+   * The regions that will be dynamically provisionable based on the user latency.
+   */
+  readonly regionsAlloweds!: pulumi.Output<string[]>;
+  /**
+   * The maximum amount of regions to be deployed at any given time.
+   */
+  readonly regionsMaxAllowed!: pulumi.Output<number | undefined>;
+  /**
+   * The regions that will be statically provisioned and will always be running and available to users.
+   */
+  readonly regionsRequireds!: pulumi.Output<string[]>;
+  /**
+   * Create a ComputeContainerApp resource with the given unique name, arguments, and options.
+   *
+   * @param name The _unique_ name of the resource.
+   * @param args The arguments to use to populate this resource's properties.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: ComputeContainerAppArgs, opts?: pulumi.CustomResourceOptions);
+}
+/**
+ * Input properties used for looking up and filtering ComputeContainerApp resources.
+ */
+interface ComputeContainerAppState {
+  /**
+   * The maximum number of instances that will be provisioned per active region.
+   */
+  autoscalingMax?: pulumi.Input<number>;
+  /**
+   * The minimum number of instances that will be provisioned per active region.
+   */
+  autoscalingMin?: pulumi.Input<number>;
+  /**
+   * Defines a container for the application.
+   */
+  containers?: pulumi.Input<pulumi.Input<ComputeContainerAppContainer>[]>;
+  /**
+   * The name of the application.
+   */
+  name?: pulumi.Input<string>;
+  /**
+   * The regions that will be dynamically provisionable based on the user latency.
+   */
+  regionsAlloweds?: pulumi.Input<pulumi.Input<string>[]>;
+  /**
+   * The maximum amount of regions to be deployed at any given time.
+   */
+  regionsMaxAllowed?: pulumi.Input<number>;
+  /**
+   * The regions that will be statically provisioned and will always be running and available to users.
+   */
+  regionsRequireds?: pulumi.Input<pulumi.Input<string>[]>;
+}
+/**
+ * The set of arguments for constructing a ComputeContainerApp resource.
+ */
+interface ComputeContainerAppArgs {
+  /**
+   * The maximum number of instances that will be provisioned per active region.
+   */
+  autoscalingMax?: pulumi.Input<number>;
+  /**
+   * The minimum number of instances that will be provisioned per active region.
+   */
+  autoscalingMin?: pulumi.Input<number>;
+  /**
+   * Defines a container for the application.
+   */
+  containers?: pulumi.Input<pulumi.Input<ComputeContainerAppContainer>[]>;
+  /**
+   * The name of the application.
+   */
+  name?: pulumi.Input<string>;
+  /**
+   * The regions that will be dynamically provisionable based on the user latency.
+   */
+  regionsAlloweds: pulumi.Input<pulumi.Input<string>[]>;
+  /**
+   * The maximum amount of regions to be deployed at any given time.
+   */
+  regionsMaxAllowed?: pulumi.Input<number>;
+  /**
+   * The regions that will be statically provisioned and will always be running and available to users.
+   */
+  regionsRequireds: pulumi.Input<pulumi.Input<string>[]>;
+}
+//#endregion
+export { ComputeContainerApp, ComputeContainerAppArgs, ComputeContainerAppState };

package/bin/computeContainerApp.mjs

@@ -0,0 +1,97 @@
+import { __esm, __export } from "./_virtual/rolldown_runtime.mjs";
+import { getPackage, init_utilities, resourceOptsDefaults } from "./utilities.mjs";
+import * as pulumi from "@pulumi/pulumi";
+
+//#region computeContainerApp.ts
+var computeContainerApp_exports = {};
+__export(computeContainerApp_exports, { ComputeContainerApp: () => ComputeContainerApp });
+var ComputeContainerApp;
+var init_computeContainerApp = __esm({ "computeContainerApp.ts": (() => {
+	init_utilities();
+	ComputeContainerApp = class ComputeContainerApp extends pulumi.CustomResource {
+		/**
+		* Get an existing ComputeContainerApp resource's state with the given name, ID, and optional extra
+		* properties used to qualify the lookup.
+		*
+		* @param name The _unique_ name of the resulting resource.
+		* @param id The _unique_ provider ID of the resource to lookup.
+		* @param state Any extra arguments used during the lookup.
+		* @param opts Optional settings to control the behavior of the CustomResource.
+		*/
+		static get(name, id, state, opts) {
+			return new ComputeContainerApp(name, state, {
+				...opts,
+				id
+			});
+		}
+		/** @internal */
+		static __pulumiType = "bunnynet:index/computeContainerApp:ComputeContainerApp";
+		/**
+		* Returns true if the given object is an instance of ComputeContainerApp.  This is designed to work even
+		* when multiple copies of the Pulumi SDK have been loaded into the same process.
+		*/
+		static isInstance(obj) {
+			if (obj === void 0 || obj === null) return false;
+			return obj["__pulumiType"] === ComputeContainerApp.__pulumiType;
+		}
+		/**
+		* The maximum number of instances that will be provisioned per active region.
+		*/
+		autoscalingMax;
+		/**
+		* The minimum number of instances that will be provisioned per active region.
+		*/
+		autoscalingMin;
+		/**
+		* Defines a container for the application.
+		*/
+		containers;
+		/**
+		* The name of the application.
+		*/
+		name;
+		/**
+		* The regions that will be dynamically provisionable based on the user latency.
+		*/
+		regionsAlloweds;
+		/**
+		* The maximum amount of regions to be deployed at any given time.
+		*/
+		regionsMaxAllowed;
+		/**
+		* The regions that will be statically provisioned and will always be running and available to users.
+		*/
+		regionsRequireds;
+		constructor(name, argsOrState, opts) {
+			let resourceInputs = {};
+			opts = opts || {};
+			if (opts.id) {
+				const state = argsOrState;
+				resourceInputs["autoscalingMax"] = state ? state.autoscalingMax : void 0;
+				resourceInputs["autoscalingMin"] = state ? state.autoscalingMin : void 0;
+				resourceInputs["containers"] = state ? state.containers : void 0;
+				resourceInputs["name"] = state ? state.name : void 0;
+				resourceInputs["regionsAlloweds"] = state ? state.regionsAlloweds : void 0;
+				resourceInputs["regionsMaxAllowed"] = state ? state.regionsMaxAllowed : void 0;
+				resourceInputs["regionsRequireds"] = state ? state.regionsRequireds : void 0;
+			} else {
+				const args = argsOrState;
+				if ((!args || args.regionsAlloweds === void 0) && !opts.urn) throw new Error("Missing required property 'regionsAlloweds'");
+				if ((!args || args.regionsRequireds === void 0) && !opts.urn) throw new Error("Missing required property 'regionsRequireds'");
+				resourceInputs["autoscalingMax"] = args ? args.autoscalingMax : void 0;
+				resourceInputs["autoscalingMin"] = args ? args.autoscalingMin : void 0;
+				resourceInputs["containers"] = args ? args.containers : void 0;
+				resourceInputs["name"] = args ? args.name : void 0;
+				resourceInputs["regionsAlloweds"] = args ? args.regionsAlloweds : void 0;
+				resourceInputs["regionsMaxAllowed"] = args ? args.regionsMaxAllowed : void 0;
+				resourceInputs["regionsRequireds"] = args ? args.regionsRequireds : void 0;
+			}
+			opts = pulumi.mergeOptions(resourceOptsDefaults(), opts);
+			super(ComputeContainerApp.__pulumiType, name, resourceInputs, opts, false, getPackage());
+		}
+	};
+}) });
+
+//#endregion
+init_computeContainerApp();
+export { computeContainerApp_exports, init_computeContainerApp };

package/bin/computeContainerImageregistry.d.mts

@@ -0,0 +1,86 @@
+import * as pulumi from "@pulumi/pulumi";
+
+//#region computeContainerImageregistry.d.ts
+declare class ComputeContainerImageregistry extends pulumi.CustomResource {
+  /**
+   * Get an existing ComputeContainerImageregistry resource's state with the given name, ID, and optional extra
+   * properties used to qualify the lookup.
+   *
+   * @param name The _unique_ name of the resulting resource.
+   * @param id The _unique_ provider ID of the resource to lookup.
+   * @param state Any extra arguments used during the lookup.
+   * @param opts Optional settings to control the behavior of the CustomResource.
+   */
+  static get(name: string, id: pulumi.Input<pulumi.ID>, state?: ComputeContainerImageregistryState, opts?: pulumi.CustomResourceOptions): ComputeContainerImageregistry;
+  /** @internal */
+  static readonly __pulumiType: string;
+  /**
+   * Returns true if the given object is an instance of ComputeContainerImageregistry.  This is designed to work even
+   * when multiple copies of the Pulumi SDK have been loaded into the same process.
+   */
+  static isInstance(obj: any): obj is ComputeContainerImageregistry;
+  /**
+   * The unique identifier for the image registry.
+   */
+  readonly computeContainerImageregistryId!: pulumi.Output<number>;
+  /**
+   * Options: `DockerHub`, `GitHub`
+   */
+  readonly registry!: pulumi.Output<string>;
+  /**
+   * The token used to authenticate to the registry. If you are importing a resource, declare the token as an empty string.
+   */
+  readonly token!: pulumi.Output<string>;
+  /**
+   * The username used to authenticate to the registry.
+   */
+  readonly username!: pulumi.Output<string>;
+  /**
+   * Create a ComputeContainerImageregistry resource with the given unique name, arguments, and options.
+   *
+   * @param name The _unique_ name of the resource.
+   * @param args The arguments to use to populate this resource's properties.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: ComputeContainerImageregistryArgs, opts?: pulumi.CustomResourceOptions);
+}
+/**
+ * Input properties used for looking up and filtering ComputeContainerImageregistry resources.
+ */
+interface ComputeContainerImageregistryState {
+  /**
+   * The unique identifier for the image registry.
+   */
+  computeContainerImageregistryId?: pulumi.Input<number>;
+  /**
+   * Options: `DockerHub`, `GitHub`
+   */
+  registry?: pulumi.Input<string>;
+  /**
+   * The token used to authenticate to the registry. If you are importing a resource, declare the token as an empty string.
+   */
+  token?: pulumi.Input<string>;
+  /**
+   * The username used to authenticate to the registry.
+   */
+  username?: pulumi.Input<string>;
+}
+/**
+ * The set of arguments for constructing a ComputeContainerImageregistry resource.
+ */
+interface ComputeContainerImageregistryArgs {
+  /**
+   * Options: `DockerHub`, `GitHub`
+   */
+  registry: pulumi.Input<string>;
+  /**
+   * The token used to authenticate to the registry. If you are importing a resource, declare the token as an empty string.
+   */
+  token: pulumi.Input<string>;
+  /**
+   * The username used to authenticate to the registry.
+   */
+  username: pulumi.Input<string>;
+}
+//#endregion
+export { ComputeContainerImageregistry, ComputeContainerImageregistryArgs, ComputeContainerImageregistryState };