> ## 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: "adminuser",
      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="adminuser",
        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("adminuser"),
                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 = "adminuser",
            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.*;
    import 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("adminuser")
                    .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: adminuser
          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.apply((id) => Number(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=pulumi.Output.from_input(vm.id).apply(int),
        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().ToIntOutput(),
        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.Apply(v => int.Parse(v)),
        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().applyValue(Integer::parseInt))
            .name("snapshot-1")
            .description("before upgrade")
            .cycle("m")
            .build());
    ```
  </Tab>

  <Tab title="YAML">
    ```yaml theme={null}
    snapshot:
      type: biznetgio:index:NeoliteSnapshot
      properties:
        neoliteAccountId: ${fn::toNumber(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.apply((id) => Number(id)),
      productId: products.products[0].productId,
      cycle: "m",
      keypairId: keypair.keypairId,
      name: "restored-1",
      sshAndConsoleUser: "adminuser",
      consolePassword: "s3cretP4ssw0rd",
    });
    ```
  </Tab>

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

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

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

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

  <Tab title="YAML">
    ```yaml theme={null}
    restored:
      type: biznetgio:index:NeoliteVmFromSnapshot
      properties:
        snapshotId: ${fn::toNumber(snapshot.id)}
        productId: ${products[0].productId}
        cycle: m
        keypairId: ${keypair.keypairId}
        name: restored-1
        sshAndConsoleUser: adminuser
        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.apply((id) => Number(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=pulumi.Output.from_input(vm.id).apply(int),
        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().ToIntOutput(),
        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.Apply(v => int.Parse(v)),
        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().applyValue(Integer::parseInt))
            .serviceName("extra-disk")
            .size(60)
            .build());
    ```
  </Tab>

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

| Input | Type | Required | Notes |
| - | - | - | - |
| `productId` | int64 | yes | from `/neolites/disks/products`; see warning below |
| `cycle` | string | yes | see warning below |
| `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.

<Warning>
  `productId` and `cycle` have no `replaceOnChanges` tag. If you change either without also changing `size`, `Update` discards the change and writes the *old* value back into state, so the next `pulumi preview` shows the same diff again - it never resolves and never errors. The Terraform equivalent (`biznetgio_neolite_disk`) correctly marks both `RequiresReplace()`. If you need a different disk product or cycle in Pulumi, destroy and recreate the resource.
</Warning>

## Functions

<Note>
  For real pricing and how to pick a specific package instead of trusting `[0]`, see the [Product Catalog](/products/neolite) page.
</Note>

### `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).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.