> ## 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 (Pulumi)

> Pulumi resources and functions for NEO Lite VPS

NEO Lite resources under the `biznetgio` package (`/neolites` API group). The typical flow chains catalog functions into a create: `neoliteProducts` → `neoliteOsList` → `NeoliteKeypair` → `NeoliteVm`.

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

## `biznetgio:index:NeoliteVm`

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

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

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

    const vm = new biznetgio.NeoliteVm("demo-vm", {
      vmName: "neo-lite-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",
      // migrateToPro: "12345",   // neolite-pro product id
      // diskSize: 100,           // absolute GB target, grow-only
    });

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

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

    products = pulumi_biznetgio.neolite_products()
    os_list = pulumi_biznetgio.neolite_os_list_output(
        product_id=products.products[0].product_id,
    )

    keypair = pulumi_biznetgio.NeoliteKeypair(
        "demo-keypair",
        name="neo-lite-key",
    )

    vm = pulumi_biznetgio.NeoliteVm(
        "demo-vm",
        vm_name="neo-lite-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",
        # optional in-place actions (change value to fire):
        # power_state="stop",
        # rebuild_os="ubuntu-22",
        # migrate_to_pro="12345",   # neolite-pro product id
        # disk_size=100,            # absolute GB target, grow-only
    )

    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.NeoliteProducts(ctx, &biznetgio.NeoliteProductsArgs{})
            if err != nil {
                return err
            }
            osList, err := biznetgio.NeoliteOsList(ctx, &biznetgio.NeoliteOsListArgs{
                ProductId: products.Products[0].ProductId,
            })
            if err != nil {
                return err
            }

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

            vm, err := biznetgio.NewNeoliteVm(ctx, "demo-vm", &biznetgio.NeoliteVmArgs{
                VmName:            pulumi.String("neo-lite-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"),
                // optional in-place actions (change value to fire):
                // PowerState: pulumi.String("stop"),
                // RebuildOs:  pulumi.String("ubuntu-22"),
                // MigrateToPro: pulumi.String("12345"),
                // 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 = NeoliteProducts.Invoke();
        var osList = NeoliteOsList.Invoke(new NeoliteOsListInvokeArgs
        {
            ProductId = products.Apply(p => p.Products[0].ProductId),
        });

        var keypair = new NeoliteKeypair("demo-keypair", new NeoliteKeypairArgs
        {
            Name = "neo-lite-key",
        });

        var vm = new NeoliteVm("demo-vm", new NeoliteVmArgs
        {
            VmName = "neo-lite-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",
            // optional in-place actions (change value to fire):
            // PowerState = "stop",
            // RebuildOs = "ubuntu-22",
            // MigrateToPro = "12345",
            // 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.neoliteProducts();
            var osList = BiznetgioFunctions.neoliteOsList(
                NeoliteOsListArgs.builder()
                    .productId(products.applyValue(p -> p.products().get(0).productId()))
                    .build());

            var keypair = new NeoliteKeypair("demo-keypair",
                NeoliteKeypairArgs.builder()
                    .name("neo-lite-key")
                    .build());

            var vm = new NeoliteVm("demo-vm",
                NeoliteVmArgs.builder()
                    .vmName("neo-lite-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")
                    // optional in-place actions (change value to fire):
                    // .powerState("stop")
                    // .rebuildOs("ubuntu-22")
                    // .migrateToPro("12345")
                    // .diskSize(100)
                    .build());

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

  <Tab title="YAML">
    ```yaml theme={null}
    resources:
      vm:
        type: biznetgio:index:NeoliteVm
        properties:
          vmName: neo-lite-1
          productId: ${products[0].productId}
          selectOs: ${osList[0].name}
          keypairId: ${keypair.keypairId}
          cycle: m
          sshAndConsoleUser: admin
          consolePassword: s3cretP4ssw0rd
          # powerState: stop
          # rebuildOs: ubuntu-22
          # migrateToPro: "12345"
          # diskSize: 100
    ```
  </Tab>
</Tabs>

| Input               | Type           | Required | Notes                                                                           |
| ------------------- | -------------- | -------- | ------------------------------------------------------------------------------- |
| `sshAndConsoleUser` | string         | yes      | set at create                                                                   |
| `consolePassword`   | string, secret | yes      | write-only: never re-fetched from the API                                       |
| `productId`         | int64          | yes      | from `neoliteProducts`; change triggers change-package                          |
| `selectOs`          | string         | yes      | from `neoliteOsList`; OS change = rebuild                                       |
| `keypairId`         | int64          | yes      | from `NeoliteKeypair`; change triggers change-keypair                           |
| `cycle`             | string         | yes      | `m a q s b t p4 p5`                                                             |
| `vmName`            | string         | no       | default `server-name`; updatable via change-vm-name                             |
| `description`       | string         | no       | default `""`                                                                    |
| `payWithCreditCard` | bool           | no       | default `true`; `false` leaves the invoice unpaid                               |
| `promocode`         | string         | no       | default `""`                                                                    |
| `powerState`        | string         | no       | `start` / `stop` / `suspend` / `resume` / `shutdown`; API called only on change |
| `rebuildOs`         | string         | no       | one-shot destructive OS reinstall                                               |
| `migrateToPro`      | string         | no       | one-shot migration; value = NEO Lite Pro `productId`                            |
| `diskSize`          | int64          | no       | absolute GB target, grow-only                                                   |

Outputs: `orderId`, `status` (`Active`/`Pending`/`Suspended`/`Terminated`), `uptime`, `maxDisk`, `maxMem`, `mem`, `cpus`, `ciUser`, `ciPassword` (secret), `osName`, `region`, `regionLabel`, `nextDue`, `recurringAmount`, `billingcycle`, `productName`, `lastInvoice` (`id`, `paidId`, `status`, `date`, `duedate`, `paybefore`, `datepaid`, `invoiceType`), `raw` (secret, redacted).

Import with `pulumi import biznetgio:index:NeoliteVm demo-vm <account_id>`.

## `biznetgio:index:NeoliteKeypair`

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

  <Tab title="Python">
    ```python theme={null}
    keypair = pulumi_biznetgio.NeoliteKeypair(
        "demo-keypair",
        name="neo-lite-key",
    )
    pulumi.export("privateKey", keypair.private_key)
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    keypair, err := biznetgio.NewNeoliteKeypair(ctx, "demo-keypair", &biznetgio.NeoliteKeypairArgs{
        Name: pulumi.String("neo-lite-key"),
    })
    ctx.Export("privateKey", keypair.PrivateKey)
    ```
  </Tab>

  <Tab title=".NET">
    ```csharp theme={null}
    var keypair = new NeoliteKeypair("demo-keypair", new NeoliteKeypairArgs
    {
        Name = "neo-lite-key",
    });
    // keypair.PrivateKey
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    var keypair = new NeoliteKeypair("demo-keypair",
        NeoliteKeypairArgs.builder()
            .name("neo-lite-key")
            .build());
    ctx.export("privateKey", keypair.privateKey());
    ```
  </Tab>

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

| Input  | Type   | Required | Notes        |
| ------ | ------ | -------- | ------------ |
| `name` | string | yes      | keypair name |

Outputs: `keypairId`, `publicKey`, `privateKey` (secret - generated server-side, returned only at creation, preserved across refreshes). No update support. Keypairs are per-service: NEO Lite keypairs can't be used on Pro/Metal/GPU.

## `biznetgio:index:NeoliteSnapshot`

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

  <Tab title="Python">
    ```python theme={null}
    snapshot = pulumi_biznetgio.NeoliteSnapshot(
        "pre-upgrade",
        neolite_account_id=vm.id,
        name="snapshot-1",
        description="before upgrade",
        cycle="m",
    )
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    snapshot, err := biznetgio.NewNeoliteSnapshot(ctx, "pre-upgrade", &biznetgio.NeoliteSnapshotArgs{
        NeoliteAccountId: vm.ID(),
        Name:             pulumi.String("snapshot-1"),
        Description:      pulumi.String("before upgrade"),
        Cycle:            pulumi.String("m"),
    })
    ```
  </Tab>

  <Tab title=".NET">
    ```csharp theme={null}
    var snapshot = new NeoliteSnapshot("pre-upgrade", new NeoliteSnapshotArgs
    {
        NeoliteAccountId = vm.Id,
        Name = "snapshot-1",
        Description = "before upgrade",
        Cycle = "m",
    });
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    var snapshot = new NeoliteSnapshot("pre-upgrade",
        NeoliteSnapshotArgs.builder()
            .neoliteAccountId(vm.id())
            .name("snapshot-1")
            .description("before upgrade")
            .cycle("m")
            .build());
    ```
  </Tab>

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

| Input               | Type   | Required | Notes                   |
| ------------------- | ------ | -------- | ----------------------- |
| `neoliteAccountId`  | int64  | yes      | VM to snapshot          |
| `cycle`             | string | yes      | `m a q s b t p4 p5`     |
| `name`              | string | no       | default `snapshot-name` |
| `description`       | string | no       | default `""`            |
| `payWithCreditCard` | bool   | no       | default `true`          |
| `promocode`         | string | no       | default `""`            |

Outputs: `orderId`, `status`. No update - any input change replaces the snapshot.

## `biznetgio:index:NeoliteVmFromSnapshot`

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    const restored = new biznetgio.NeoliteVmFromSnapshot("restored", {
      snapshotId: snapshot.id,
      productId: products.products[0].productId,
      cycle: "m",
      keypairId: keypair.keypairId,
      name: "restored-1",
      sshAndConsoleUser: "admin",
      consolePassword: "s3cretP4ssw0rd",
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    restored = pulumi_biznetgio.NeoliteVmFromSnapshot(
        "restored",
        snapshot_id=snapshot.id,
        product_id=products.products[0].product_id,
        cycle="m",
        keypair_id=keypair.keypair_id,
        name="restored-1",
        ssh_and_console_user="admin",
        console_password="s3cretP4ssw0rd",
    )
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    restored, err := biznetgio.NewNeoliteVmFromSnapshot(ctx, "restored", &biznetgio.NeoliteVmFromSnapshotArgs{
        SnapshotId:        snapshot.ID(),
        ProductId:         pulumi.Int(products.Products[0].ProductId),
        Cycle:             pulumi.String("m"),
        KeypairId:         keypair.KeypairId,
        Name:              pulumi.String("restored-1"),
        SshAndConsoleUser: pulumi.String("admin"),
        ConsolePassword:   pulumi.String("s3cretP4ssw0rd"),
    })
    ```
  </Tab>

  <Tab title=".NET">
    ```csharp theme={null}
    var restored = new NeoliteVmFromSnapshot("restored", new NeoliteVmFromSnapshotArgs
    {
        SnapshotId = snapshot.Id,
        ProductId = products.Apply(p => p.Products[0].ProductId),
        Cycle = "m",
        KeypairId = keypair.KeypairId,
        Name = "restored-1",
        SshAndConsoleUser = "admin",
        ConsolePassword = "s3cretP4ssw0rd",
    });
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    var restored = new NeoliteVmFromSnapshot("restored",
        NeoliteVmFromSnapshotArgs.builder()
            .snapshotId(snapshot.id())
            .productId(products.applyValue(p -> p.products().get(0).productId()))
            .cycle("m")
            .keypairId(keypair.keypairId())
            .name("restored-1")
            .sshAndConsoleUser("admin")
            .consolePassword("s3cretP4ssw0rd")
            .build());
    ```
  </Tab>

  <Tab title="YAML">
    ```yaml theme={null}
    restored:
      type: biznetgio:index:NeoliteVmFromSnapshot
      properties:
        snapshotId: ${snapshot.id}
        productId: ${products[0].productId}
        cycle: m
        keypairId: ${keypair.keypairId}
        name: restored-1
        sshAndConsoleUser: admin
        consolePassword: s3cretP4ssw0rd
    ```
  </Tab>
</Tabs>

| Input               | Type           | Required | Notes                  |
| ------------------- | -------------- | -------- | ---------------------- |
| `snapshotId`        | int64          | yes      | from `NeoliteSnapshot` |
| `productId`         | int64          | yes      |                        |
| `cycle`             | string         | yes      |                        |
| `keypairId`         | int64          | yes      |                        |
| `name`              | string         | yes      |                        |
| `sshAndConsoleUser` | string         | yes      |                        |
| `consolePassword`   | string, secret | yes      |                        |
| `description`       | string         | no       | default `""`           |
| `promocode`         | string         | no       | default `""`           |
| `payWithCreditCard` | bool           | no       | default `true`         |

Outputs: `orderId`, `status`. **Deleting this resource deletes the restored VM - never the snapshot.** No update support.

## `biznetgio:index:NeoliteDisk`

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    const disk = new biznetgio.NeoliteDisk("extra", {
      productId: 60,
      cycle: "m",
      neoliteAccountId: vm.id,
      serviceName: "extra-disk",
      size: 60,   // grow-only; upgrades send the increment
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    disk = pulumi_biznetgio.NeoliteDisk(
        "extra",
        product_id=60,
        cycle="m",
        neolite_account_id=vm.id,
        service_name="extra-disk",
        size=60,   # grow-only; upgrades send the increment
    )
    ```
  </Tab>

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

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

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

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

| Input               | Type   | Required | Notes                           |
| ------------------- | ------ | -------- | ------------------------------- |
| `productId`         | int64  | yes      | from `/neolites/disks/products` |
| `cycle`             | string | yes      |                                 |
| `neoliteAccountId`  | int64  | yes      | target VM                       |
| `serviceName`       | string | no       | default `service-name`          |
| `size`              | int64  | no       | default `60` GB, grow-only      |
| `promocode`         | string | no       |                                 |
| `payWithCreditCard` | bool   | no       | default `true`                  |

Outputs: `orderId`, `status`, `raw` (secret). Update upgrades size only - the API receives the increment (`newSize - oldSize`), not the absolute target; shrinking errors.

## Functions

### `biznetgio:index:neoliteProducts`

No arguments. Returns `products`: `productId`, `name`, `description`, `categoryId`, `categoryName`, `options` (`type`, `cores`, `memory`, `allowDowngrade`), `billing` (`label`, `cycle`, `price`, `components` with per-quantity `prices`).

### `biznetgio:index:neoliteOsList`

Argument `productId` (int64). Returns `oss`: `vmid`, `node`, `name` (use for `selectOs`), `maxmem`, `maxcpu`.

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    const products = biznetgio.neoliteProductsOutput();
    const osList = biznetgio.neoliteOsListOutput({
      productId: products.products[0].productId,
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    products = pulumi_biznetgio.neolite_products()
    os_list = pulumi_biznetgio.neolite_os_list_output(
        product_id=products.products[0].product_id,
    )
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    products, _ := biznetgio.NeoliteProducts(ctx, &biznetgio.NeoliteProductsArgs{})
    osList, _ := biznetgio.NeoliteOsList(ctx, &biznetgio.NeoliteOsListArgs{
        ProductId: products.Products[0].ProductId,
    })
    ```
  </Tab>

  <Tab title=".NET">
    ```csharp theme={null}
    var products = NeoliteProducts.Invoke();
    var osList = NeoliteOsList.Invoke(new NeoliteOsListInvokeArgs
    {
        ProductId = products.Apply(p => p.Products[0].ProductId),
    });
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    var products = BiznetgioFunctions.neoliteProducts();
    var osList = BiznetgioFunctions.neoliteOsList(
        NeoliteOsListArgs.builder()
            .productId(products.applyValue(p -> p.products().get(0).productId()))
            .build());
    ```
  </Tab>

  <Tab title="YAML">
    ```yaml theme={null}
    variables:
      products:
        fn::invoke:
          function: biznetgio:index:neoliteProducts
          return: products
      osList:
        fn::invoke:
          function: biznetgio:index:neoliteOsList
          arguments:
            productId: ${products[0].productId}
          return: oss
    ```
  </Tab>
</Tabs>

### `biznetgio:index:neoliteChangePackageOptions`

Argument `accountId`. Returns `raw` (secret) - the upstream response is unmodeled and exported as JSON.

### `biznetgio:index:neoliteStorageUpgradeOptions`

Argument `accountId`. Returns `raw` (secret).

### `biznetgio:index:neoliteIPAvailability`

Argument `productId`. Returns `available` (bool).