> ## Documentation Index
> Fetch the complete documentation index at: https://biznetgio.creations.ren/llms.txt
> Use this file to discover all available pages before exploring further.

# NEO Lite Pro (Pulumi)

> Pulumi resources and functions for NEO Lite Pro VPS

NEO Lite Pro is the premium VPS tier (`/neolite-pros` API group). The resource set mirrors NEO Lite with its own keypair, snapshot, and disk pools, and no `migrateToPro` (Pro is the migration *destination*).

<Info>
  Every create/upgrade places a **real paid order**. Read the [billing guide](/guides/billing) for `cycle` values and `payWithCreditCard` semantics.
</Info>

## `biznetgio:index:NeoliteProVm`

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    import * as biznetgio from "@shirasakaren/biznetgio";

    const products = biznetgio.neoliteProProductsOutput();
    const osList = biznetgio.neoliteProOsListOutput({
      productId: products.products[0].productId,
    });

    const keypair = new biznetgio.NeoliteProKeypair("pro-keypair", {
      name: "neo-lite-pro-key",
    });

    const vm = new biznetgio.NeoliteProVm("pro-vm", {
      vmName: "neo-pro-1",
      productId: products.products[0].productId,
      selectOs: osList.oss[0].name,
      keypairId: keypair.keypairId,
      cycle: "m",
      sshAndConsoleUser: "admin",
      consolePassword: "s3cretP4ssw0rd",
      // optional in-place actions (change value to fire):
      // powerState: "stop",
      // rebuildOs: "ubuntu-22",
      // diskSize: 100,
    });

    export const vmStatus = vm.status;
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    import pulumi
    import pulumi_biznetgio

    products = pulumi_biznetgio.neolite_pro_products()
    os_list = pulumi_biznetgio.neolite_pro_os_list_output(
        product_id=products.products[0].product_id,
    )

    keypair = pulumi_biznetgio.NeoliteProKeypair(
        "pro-keypair",
        name="neo-lite-pro-key",
    )

    vm = pulumi_biznetgio.NeoliteProVm(
        "pro-vm",
        vm_name="neo-pro-1",
        product_id=products.products[0].product_id,
        select_os=os_list.oss[0].name,
        keypair_id=keypair.keypair_id,
        cycle="m",
        ssh_and_console_user="admin",
        console_password="s3cretP4ssw0rd",
        # power_state="stop",
        # rebuild_os="ubuntu-22",
        # disk_size=100,
    )

    pulumi.export("vmStatus", vm.status)
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    package main

    import (
        biznetgio "github.com/shirasakaren/pulumi-biznetgio/sdk/go/pulumi-biznetgio"
        "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )

    func main() {
        pulumi.Run(func(ctx *pulumi.Context) error {
            products, err := biznetgio.NeoliteProProducts(ctx, &biznetgio.NeoliteProProductsArgs{})
            if err != nil {
                return err
            }
            osList, err := biznetgio.NeoliteProOsList(ctx, &biznetgio.NeoliteProOsListArgs{
                ProductId: products.Products[0].ProductId,
            })
            if err != nil {
                return err
            }

            keypair, err := biznetgio.NewNeoliteProKeypair(ctx, "pro-keypair", &biznetgio.NeoliteProKeypairArgs{
                Name: pulumi.String("neo-lite-pro-key"),
            })
            if err != nil {
                return err
            }

            vm, err := biznetgio.NewNeoliteProVm(ctx, "pro-vm", &biznetgio.NeoliteProVmArgs{
                VmName:            pulumi.String("neo-pro-1"),
                ProductId:         pulumi.Int(products.Products[0].ProductId),
                SelectOs:          pulumi.String(osList.Oss[0].Name),
                KeypairId:         keypair.KeypairId,
                Cycle:             pulumi.String("m"),
                SshAndConsoleUser: pulumi.String("admin"),
                ConsolePassword:   pulumi.String("s3cretP4ssw0rd"),
                // PowerState: pulumi.String("stop"),
                // RebuildOs:  pulumi.String("ubuntu-22"),
                // DiskSize:   pulumi.Int(100),
            })
            if err != nil {
                return err
            }

            ctx.Export("vmStatus", vm.Status)
            return nil
        })
    }
    ```
  </Tab>

  <Tab title=".NET">
    ```csharp theme={null}
    using System;
    using System.Collections.Generic;
    using Pulumi;
    using Shirasakaren.Biznetgio;

    return await Deployment.RunAsync(() =>
    {
        var products = NeoliteProProducts.Invoke();
        var osList = NeoliteProOsList.Invoke(new NeoliteProOsListInvokeArgs
        {
            ProductId = products.Apply(p => p.Products[0].ProductId),
        });

        var keypair = new NeoliteProKeypair("pro-keypair", new NeoliteProKeypairArgs
        {
            Name = "neo-lite-pro-key",
        });

        var vm = new NeoliteProVm("pro-vm", new NeoliteProVmArgs
        {
            VmName = "neo-pro-1",
            ProductId = products.Apply(p => p.Products[0].ProductId),
            SelectOs = osList.Apply(o => o.Oss[0].Name),
            KeypairId = keypair.KeypairId,
            Cycle = "m",
            SshAndConsoleUser = "admin",
            ConsolePassword = "s3cretP4ssw0rd",
            // PowerState = "stop",
            // RebuildOs = "ubuntu-22",
            // DiskSize = 100,
        });

        return new Dictionary<string, object?>
        {
            ["vmStatus"] = vm.Status,
        };
    });
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    package demo;

    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import ren.shirasaka.biznetgio.ren.shirasaka_biznetgio.*;
    import ren.shirasaka.biznetgio.ren.shirasaka_biznetgio.inputs.*;

    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }

        private static void stack(Context ctx) {
            var products = BiznetgioFunctions.neoliteProProducts();
            var osList = BiznetgioFunctions.neoliteProOsList(
                NeoliteProOsListArgs.builder()
                    .productId(products.applyValue(p -> p.products().get(0).productId()))
                    .build());

            var keypair = new NeoliteProKeypair("pro-keypair",
                NeoliteProKeypairArgs.builder()
                    .name("neo-lite-pro-key")
                    .build());

            var vm = new NeoliteProVm("pro-vm",
                NeoliteProVmArgs.builder()
                    .vmName("neo-pro-1")
                    .productId(products.applyValue(p -> p.products().get(0).productId()))
                    .selectOs(osList.applyValue(o -> o.oss().get(0).name()))
                    .keypairId(keypair.keypairId())
                    .cycle("m")
                    .sshAndConsoleUser("admin")
                    .consolePassword("s3cretP4ssw0rd")
                    // .powerState("stop")
                    // .rebuildOs("ubuntu-22")
                    // .diskSize(100)
                    .build());

            ctx.export("vmStatus", vm.status());
        }
    }
    ```
  </Tab>

  <Tab title="YAML">
    ```yaml theme={null}
    resources:
      vm:
        type: biznetgio:index:NeoliteProVm
        properties:
          vmName: neo-pro-1
          productId: ${products[0].productId}
          selectOs: ${osList[0].name}
          keypairId: ${keypair.keypairId}
          cycle: m
          sshAndConsoleUser: admin
          consolePassword: s3cretP4ssw0rd
    ```
  </Tab>
</Tabs>

Identical inputs to [`NeoliteVm`](/pulumi/resources/neolite#biznetgioindexneolitevm) minus `migrateToPro`:

| Input               | Type           | Required | Notes                                                     |
| ------------------- | -------------- | -------- | --------------------------------------------------------- |
| `sshAndConsoleUser` | string         | yes      |                                                           |
| `consolePassword`   | string, secret | yes      | write-only                                                |
| `productId`         | int64          | yes      | from `neoliteProProducts`; change triggers change-package |
| `selectOs`          | string         | yes      | from `neoliteProOsList`                                   |
| `keypairId`         | int64          | yes      | from `NeoliteProKeypair`; change triggers change-keypair  |
| `cycle`             | string         | yes      | `m a q s b t p4 p5`                                       |
| `vmName`            | string         | no       | default `server-name`; updatable                          |
| `description`       | string         | no       | default `""`                                              |
| `payWithCreditCard` | bool           | no       | default `true`                                            |
| `promocode`         | string         | no       | default `""`                                              |
| `powerState`        | string         | no       | `start` / `stop` / `suspend` / `resume` / `shutdown`      |
| `rebuildOs`         | string         | no       | one-shot destructive reinstall                            |
| `diskSize`          | int64          | no       | absolute GB target, grow-only                             |

Outputs identical to `NeoliteVm` (including `lastInvoice` and redacted `raw`). Import with the numeric account id.

## `biznetgio:index:NeoliteProKeypair`

Same shape as [`NeoliteKeypair`](/pulumi/resources/neolite#biznetgioindexneolitekeypair), in the Pro pool:

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    const keypair = new biznetgio.NeoliteProKeypair("pro-keypair", {
      name: "neo-lite-pro-key",
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    keypair = pulumi_biznetgio.NeoliteProKeypair(
        "pro-keypair",
        name="neo-lite-pro-key",
    )
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    keypair, err := biznetgio.NewNeoliteProKeypair(ctx, "pro-keypair", &biznetgio.NeoliteProKeypairArgs{
        Name: pulumi.String("neo-lite-pro-key"),
    })
    ```
  </Tab>

  <Tab title=".NET">
    ```csharp theme={null}
    var keypair = new NeoliteProKeypair("pro-keypair", new NeoliteProKeypairArgs
    {
        Name = "neo-lite-pro-key",
    });
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    var keypair = new NeoliteProKeypair("pro-keypair",
        NeoliteProKeypairArgs.builder()
            .name("neo-lite-pro-key")
            .build());
    ```
  </Tab>

  <Tab title="YAML">
    ```yaml theme={null}
    keypair:
      type: biznetgio:index:NeoliteProKeypair
      properties:
        name: neo-lite-pro-key
    ```
  </Tab>
</Tabs>

Input `name`; outputs `keypairId`, `publicKey`, `privateKey` (secret, once). No update.

## `biznetgio:index:NeoliteProSnapshot`

Same shape as [`NeoliteSnapshot`](/pulumi/resources/neolite#biznetgioindexneolitesnapshot):

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    const snapshot = new biznetgio.NeoliteProSnapshot("pro-snapshot", {
      neoliteAccountId: vm.id,
      name: "pro-snapshot",
      cycle: "m",
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    snapshot = pulumi_biznetgio.NeoliteProSnapshot(
        "pro-snapshot",
        neolite_account_id=vm.id,
        name="pro-snapshot",
        cycle="m",
    )
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    snapshot, err := biznetgio.NewNeoliteProSnapshot(ctx, "pro-snapshot", &biznetgio.NeoliteProSnapshotArgs{
        NeoliteAccountId: vm.ID(),
        Name:             pulumi.String("pro-snapshot"),
        Cycle:            pulumi.String("m"),
    })
    ```
  </Tab>

  <Tab title=".NET">
    ```csharp theme={null}
    var snapshot = new NeoliteProSnapshot("pro-snapshot", new NeoliteProSnapshotArgs
    {
        NeoliteAccountId = vm.Id,
        Name = "pro-snapshot",
        Cycle = "m",
    });
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    var snapshot = new NeoliteProSnapshot("pro-snapshot",
        NeoliteProSnapshotArgs.builder()
            .neoliteAccountId(vm.id())
            .name("pro-snapshot")
            .cycle("m")
            .build());
    ```
  </Tab>

  <Tab title="YAML">
    ```yaml theme={null}
    snapshot:
      type: biznetgio:index:NeoliteProSnapshot
      properties:
        neoliteAccountId: ${vm.id}
        name: pro-snapshot
        cycle: m
    ```
  </Tab>
</Tabs>

Inputs `neoliteAccountId` (required), `cycle` (required), `name` (default `snapshot-name`), `description`, `payWithCreditCard` (default `true`), `promocode`; outputs `orderId`, `status`. No update.

## `biznetgio:index:NeoliteProDisk`

Same shape as [`NeoliteDisk`](/pulumi/resources/neolite#biznetgioindexneolitedisk) with a 30 GB minimum/default:

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    const disk = new biznetgio.NeoliteProDisk("pro-extra", {
      productId: 60,
      cycle: "m",
      neoliteAccountId: vm.id,
      serviceName: "pro-extra-disk",
      size: 30,
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    disk = pulumi_biznetgio.NeoliteProDisk(
        "pro-extra",
        product_id=60,
        cycle="m",
        neolite_account_id=vm.id,
        service_name="pro-extra-disk",
        size=30,
    )
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    disk, err := biznetgio.NewNeoliteProDisk(ctx, "pro-extra", &biznetgio.NeoliteProDiskArgs{
        ProductId:        pulumi.Int(60),
        Cycle:            pulumi.String("m"),
        NeoliteAccountId: vm.ID(),
        ServiceName:      pulumi.String("pro-extra-disk"),
        Size:             pulumi.Int(30),
    })
    ```
  </Tab>

  <Tab title=".NET">
    ```csharp theme={null}
    var disk = new NeoliteProDisk("pro-extra", new NeoliteProDiskArgs
    {
        ProductId = 60,
        Cycle = "m",
        NeoliteAccountId = vm.Id,
        ServiceName = "pro-extra-disk",
        Size = 30,
    });
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    var disk = new NeoliteProDisk("pro-extra",
        NeoliteProDiskArgs.builder()
            .productId(60)
            .cycle("m")
            .neoliteAccountId(vm.id())
            .serviceName("pro-extra-disk")
            .size(30)
            .build());
    ```
  </Tab>

  <Tab title="YAML">
    ```yaml theme={null}
    disk:
      type: biznetgio:index:NeoliteProDisk
      properties:
        productId: 60
        cycle: m
        neoliteAccountId: ${vm.id}
        serviceName: pro-extra-disk
        size: 30
    ```
  </Tab>
</Tabs>

Upgrades send the increment (`additional_size`); shrinking errors.

## Functions

All five mirror the NEO Lite functions against `/neolite-pros`:

### `biznetgio:index:neoliteProProducts`

No arguments. Same nested structure as `neoliteProducts` (`options`, `billing`, `components`, `prices`).

### `biznetgio:index:neoliteProOsList`

Argument `productId`; returns `oss` (`vmid`, `node`, `name`, `maxmem`, `maxcpu`).

### `biznetgio:index:neoliteProChangePackageOptions`

Argument `accountId`; returns `raw` (secret).

### `biznetgio:index:neoliteProStorageUpgradeOptions`

Argument `accountId`; returns `raw` (secret).

### `biznetgio:index:neoliteProIPAvailability`

Argument `productId`; returns `available` (bool).