shared.ts

// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

import * as Shared from './shared';

export interface Action {
  /**
   * A unique numeric ID that can be used to identify and reference an action.
   */
  id?: number;

  /**
   * A time value given in ISO8601 combined date and time format that represents when
   * the action was completed.
   */
  completed_at?: string | null;

  region?: Region;

  /**
   * A human-readable string that is used as a unique identifier for each region.
   */
  region_slug?: string | null;

  /**
   * A unique identifier for the resource that the action is associated with.
   */
  resource_id?: number | null;

  /**
   * The type of resource that the action is associated with.
   */
  resource_type?: string;

  /**
   * A time value given in ISO8601 combined date and time format that represents when
   * the action was initiated.
   */
  started_at?: string;

  /**
   * The current status of the action. This can be "in-progress", "completed", or
   * "errored".
   */
  status?: 'in-progress' | 'completed' | 'errored';

  /**
   * This is the type of action that the object represents. For example, this could
   * be "transfer" to represent the state of an image transfer action.
   */
  type?: string;
}

/**
 * The linked actions can be used to check the status of a Droplet's create event.
 */
export interface ActionLink {
  /**
   * A unique numeric ID that can be used to identify and reference an action.
   */
  id?: number;

  /**
   * A URL that can be used to access the action.
   */
  href?: string;

  /**
   * A string specifying the type of the related action.
   */
  rel?: string;
}

/**
 * Links to other pages
 */
export interface APILinks {
  /**
   * Information about how to reach other pages
   */
  pages?: APILinks.Pages;
}

export namespace APILinks {
  /**
   * Information about how to reach other pages
   */
  export interface Pages {
    /**
     * First page
     */
    first?: string;

    /**
     * Last page
     */
    last?: string;

    /**
     * Next page
     */
    next?: string;

    /**
     * Previous page
     */
    previous?: string;
  }
}

/**
 * Meta information about the data set
 */
export interface APIMeta {
  /**
   * The current page
   */
  page?: number;

  /**
   * Total number of pages
   */
  pages?: number;

  /**
   * Total amount of items over all pages
   */
  total?: number;
}

export interface BackwardLinks {
  /**
   * URI of the first page of the results.
   */
  first?: string;

  /**
   * URI of the previous page of the results.
   */
  prev?: string;
}

/**
 * Represents a streamed chunk of a chat completion response returned by the model,
 * based on the provided input.
 */
export interface ChatCompletionChunk {
  /**
   * A unique identifier for the chat completion. Each chunk has the same ID.
   */
  id: string;

  /**
   * A list of chat completion choices. Can contain more than one elements if `n` is
   * greater than 1. Can also be empty for the last chunk if you set
   * `stream_options: {"include_usage": true}`.
   */
  choices: Array<ChatCompletionChunk.Choice>;

  /**
   * The Unix timestamp (in seconds) of when the chat completion was created. Each
   * chunk has the same timestamp.
   */
  created: number;

  /**
   * The model to generate the completion.
   */
  model: string;

  /**
   * The object type, which is always `chat.completion.chunk`.
   */
  object: 'chat.completion.chunk';

  /**
   * An optional field that will only be present when you set
   * `stream_options: {"include_usage": true}` in your request. When present, it
   * contains a null value **except for the last chunk** which contains the token
   * usage statistics for the entire request.
   *
   * **NOTE:** If the stream is interrupted or cancelled, you may not receive the
   * final usage chunk which contains the total token usage for the request.
   */
  usage?: CompletionUsage | null;
}

export namespace ChatCompletionChunk {
  export interface Choice {
    /**
     * A chat completion delta generated by streamed model responses.
     */
    delta: Choice.Delta;

    /**
     * The reason the model stopped generating tokens. This will be `stop` if the model
     * hit a natural stop point or a provided stop sequence, or `length` if the maximum
     * number of tokens specified in the request was reached, `tool_calls` if the model
     * called a tool.
     */
    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | null;

    /**
     * The index of the choice in the list of choices.
     */
    index: number;

    /**
     * Log probability information for the choice.
     */
    logprobs?: Choice.Logprobs | null;
  }

  export namespace Choice {
    /**
     * A chat completion delta generated by streamed model responses.
     */
    export interface Delta {
      /**
       * The contents of the chunk message.
       */
      content?: string | null;

      /**
       * The reasoning content generated by the model.
       */
      reasoning_content?: string | null;

      /**
       * The refusal message generated by the model.
       */
      refusal?: string | null;

      /**
       * The role of the author of this message.
       */
      role?: 'developer' | 'user' | 'assistant';

      tool_calls?: Array<Delta.ToolCall>;
    }

    export namespace Delta {
      export interface ToolCall {
        index: number;

        /**
         * The ID of the tool call.
         */
        id?: string;

        /**
         * A chunk of a function that the model called.
         */
        function?: ToolCall.Function;

        /**
         * The type of the tool. Currently, only `function` is supported.
         */
        type?: 'function';
      }

      export namespace ToolCall {
        /**
         * A chunk of a function that the model called.
         */
        export interface Function {
          /**
           * The arguments to call the function with, as generated by the model in JSON
           * format. Note that the model does not always generate valid JSON, and may
           * hallucinate parameters not defined by your function schema. Validate the
           * arguments in your code before calling your function.
           */
          arguments?: string;

          /**
           * The name of the function to call.
           */
          name?: string;
        }
      }
    }

    /**
     * Log probability information for the choice.
     */
    export interface Logprobs {
      /**
       * A list of message content tokens with log probability information.
       */
      content: Array<Shared.ChatCompletionTokenLogprob> | null;

      /**
       * A list of message refusal tokens with log probability information.
       */
      refusal: Array<Shared.ChatCompletionTokenLogprob> | null;
    }
  }
}

export interface ChatCompletionTokenLogprob {
  /**
   * The token.
   */
  token: string;

  /**
   * A list of integers representing the UTF-8 bytes representation of the token.
   * Useful in instances where characters are represented by multiple tokens and
   * their byte representations must be combined to generate the correct text
   * representation. Can be `null` if there is no bytes representation for the token.
   */
  bytes: Array<number> | null;

  /**
   * The log probability of this token, if it is within the top 20 most likely
   * tokens. Otherwise, the value `-9999.0` is used to signify that the token is very
   * unlikely.
   */
  logprob: number;

  /**
   * List of the most likely tokens and their log probability, at this token
   * position. In rare cases, there may be fewer than the number of requested
   * `top_logprobs` returned.
   */
  top_logprobs: Array<ChatCompletionTokenLogprob.TopLogprob>;
}

export namespace ChatCompletionTokenLogprob {
  export interface TopLogprob {
    /**
     * The token.
     */
    token: string;

    /**
     * A list of integers representing the UTF-8 bytes representation of the token.
     * Useful in instances where characters are represented by multiple tokens and
     * their byte representations must be combined to generate the correct text
     * representation. Can be `null` if there is no bytes representation for the token.
     */
    bytes: Array<number> | null;

    /**
     * The log probability of this token, if it is within the top 20 most likely
     * tokens. Otherwise, the value `-9999.0` is used to signify that the token is very
     * unlikely.
     */
    logprob: number;
  }
}

/**
 * Usage statistics for the completion request.
 */
export interface CompletionUsage {
  /**
   * Number of tokens in the generated completion.
   */
  completion_tokens: number;

  /**
   * Number of tokens in the prompt.
   */
  prompt_tokens: number;

  /**
   * Total number of tokens used in the request (prompt + completion).
   */
  total_tokens: number;
}

export interface DiskInfo {
  size?: DiskInfo.Size;

  /**
   * The type of disk. All Droplets contain a `local` disk. Additionally, GPU
   * Droplets can also have a `scratch` disk for non-persistent data.
   */
  type?: 'local' | 'scratch';
}

export namespace DiskInfo {
  export interface Size {
    /**
     * The amount of space allocated to the disk.
     */
    amount?: number;

    /**
     * The unit of measure for the disk size.
     */
    unit?: string;
  }
}

export interface Droplet {
  /**
   * A unique identifier for each Droplet instance. This is automatically generated
   * upon Droplet creation.
   */
  id: number;

  /**
   * An array of backup IDs of any backups that have been taken of the Droplet
   * instance. Droplet backups are enabled at the time of the instance creation.
   * Requires `image:read` scope.
   */
  backup_ids: Array<number>;

  /**
   * A time value given in ISO8601 combined date and time format that represents when
   * the Droplet was created.
   */
  created_at: string;

  /**
   * The size of the Droplet's disk in gigabytes.
   */
  disk: number;

  /**
   * An array of features enabled on this Droplet.
   */
  features: Array<string>;

  /**
   * The Droplet's image. Requires `image:read` scope.
   */
  image: Image;

  /**
   * A boolean value indicating whether the Droplet has been locked, preventing
   * actions by users.
   */
  locked: boolean;

  /**
   * Memory of the Droplet in megabytes.
   */
  memory: number;

  /**
   * The human-readable name set for the Droplet instance.
   */
  name: string;

  /**
   * The details of the network that are configured for the Droplet instance. This is
   * an object that contains keys for IPv4 and IPv6. The value of each of these is an
   * array that contains objects describing an individual IP resource allocated to
   * the Droplet. These will define attributes like the IP address, netmask, and
   * gateway of the specific network depending on the type of network it is.
   */
  networks: Droplet.Networks;

  /**
   * The details of the Droplet's backups feature, if backups are configured for the
   * Droplet. This object contains keys for the start and end times of the window
   * during which the backup will start.
   */
  next_backup_window: DropletNextBackupWindow | null;

  region: Region;

  size: Size;

  /**
   * The unique slug identifier for the size of this Droplet.
   */
  size_slug: string;

  /**
   * An array of snapshot IDs of any snapshots created from the Droplet instance.
   * Requires `image:read` scope.
   */
  snapshot_ids: Array<number>;

  /**
   * A status string indicating the state of the Droplet instance. This may be "new",
   * "active", "off", or "archive".
   */
  status: 'new' | 'active' | 'off' | 'archive';

  /**
   * An array of Tags the Droplet has been tagged with. Requires `tag:read` scope.
   */
  tags: Array<string>;

  /**
   * The number of virtual CPUs.
   */
  vcpus: number;

  /**
   * A flat array including the unique identifier for each Block Storage volume
   * attached to the Droplet. Requires `block_storage:read` scope.
   */
  volume_ids: Array<string>;

  /**
   * An array of objects containing information about the disks available to the
   * Droplet.
   */
  disk_info?: Array<DiskInfo>;

  /**
   * An object containing information about the GPU capabilities of Droplets created
   * with this size.
   */
  gpu_info?: GPUInfo;

  /**
   * @deprecated **Note**: All Droplets created after March 2017 use internal kernels
   * by default. These Droplets will have this attribute set to `null`.
   *
   * The current
   * [kernel](https://docs.digitalocean.com/products/droplets/how-to/kernel/) for
   * Droplets with externally managed kernels. This will initially be set to the
   * kernel of the base image when the Droplet is created.
   */
  kernel?: Kernel | null;

  /**
   * A string specifying the UUID of the VPC to which the Droplet is assigned.
   * Requires `vpc:read` scope.
   */
  vpc_uuid?: string;
}

export namespace Droplet {
  /**
   * The details of the network that are configured for the Droplet instance. This is
   * an object that contains keys for IPv4 and IPv6. The value of each of these is an
   * array that contains objects describing an individual IP resource allocated to
   * the Droplet. These will define attributes like the IP address, netmask, and
   * gateway of the specific network depending on the type of network it is.
   */
  export interface Networks {
    v4?: Array<Shared.NetworkV4>;

    v6?: Array<Shared.NetworkV6>;
  }
}

export interface DropletNextBackupWindow {
  /**
   * A time value given in ISO8601 combined date and time format specifying the end
   * of the Droplet's backup window.
   */
  end?: string;

  /**
   * A time value given in ISO8601 combined date and time format specifying the start
   * of the Droplet's backup window.
   */
  start?: string;
}

export interface FirewallRuleTarget {
  /**
   * An array of strings containing the IPv4 addresses, IPv6 addresses, IPv4 CIDRs,
   * and/or IPv6 CIDRs to which the firewall will allow traffic.
   */
  addresses?: Array<string>;

  /**
   * An array containing the IDs of the Droplets to which the firewall will allow
   * traffic.
   */
  droplet_ids?: Array<number>;

  /**
   * An array containing the IDs of the Kubernetes clusters to which the firewall
   * will allow traffic.
   */
  kubernetes_ids?: Array<string>;

  /**
   * An array containing the IDs of the load balancers to which the firewall will
   * allow traffic.
   */
  load_balancer_uids?: Array<string>;

  /**
   * A flat array of tag names as strings to be applied to the resource. Tag names
   * must exist in order to be referenced in a request.
   *
   * Requires `tag:create` and `tag:read` scopes.
   */
  tags?: Array<string> | null;
}

export interface ForwardLinks {
  /**
   * URI of the last page of the results.
   */
  last?: string;

  /**
   * URI of the next page of the results.
   */
  next?: string;
}

export interface GarbageCollection {
  /**
   * The number of blobs deleted as a result of this garbage collection.
   */
  blobs_deleted?: number;

  /**
   * The time the garbage collection was created.
   */
  created_at?: string;

  /**
   * The number of bytes freed as a result of this garbage collection.
   */
  freed_bytes?: number;

  /**
   * The name of the container registry.
   */
  registry_name?: string;

  /**
   * The current status of this garbage collection.
   */
  status?:
    | 'requested'
    | 'waiting for write JWTs to expire'
    | 'scanning manifests'
    | 'deleting unreferenced blobs'
    | 'cancelling'
    | 'failed'
    | 'succeeded'
    | 'cancelled';

  /**
   * The time the garbage collection was last updated.
   */
  updated_at?: string;

  /**
   * A string specifying the UUID of the garbage collection.
   */
  uuid?: string;
}

/**
 * An object containing information about the GPU capabilities of Droplets created
 * with this size.
 */
export interface GPUInfo {
  /**
   * The number of GPUs allocated to the Droplet.
   */
  count?: number;

  /**
   * The model of the GPU.
   */
  model?: string;

  vram?: GPUInfo.Vram;
}

export namespace GPUInfo {
  export interface Vram {
    /**
     * The amount of VRAM allocated to the GPU.
     */
    amount?: number;

    /**
     * The unit of measure for the VRAM.
     */
    unit?: string;
  }
}

export interface Image {
  /**
   * A unique number that can be used to identify and reference a specific image.
   */
  id?: number;

  /**
   * A time value given in ISO8601 combined date and time format that represents when
   * the image was created.
   */
  created_at?: string;

  /**
   * An optional free-form text field to describe an image.
   */
  description?: string;

  /**
   * The name of a custom image's distribution. Currently, the valid values are
   * `Arch Linux`, `CentOS`, `CoreOS`, `Debian`, `Fedora`, `Fedora Atomic`,
   * `FreeBSD`, `Gentoo`, `openSUSE`, `RancherOS`, `Rocky Linux`, `Ubuntu`, and
   * `Unknown`. Any other value will be accepted but ignored, and `Unknown` will be
   * used in its place.
   */
  distribution?:
    | 'Arch Linux'
    | 'CentOS'
    | 'CoreOS'
    | 'Debian'
    | 'Fedora'
    | 'Fedora Atomic'
    | 'FreeBSD'
    | 'Gentoo'
    | 'openSUSE'
    | 'RancherOS'
    | 'Rocky Linux'
    | 'Ubuntu'
    | 'Unknown';

  /**
   * A string containing information about errors that may occur when importing a
   * custom image.
   */
  error_message?: string;

  /**
   * The minimum disk size in GB required for a Droplet to use this image.
   */
  min_disk_size?: number | null;

  /**
   * The display name that has been given to an image. This is what is shown in the
   * control panel and is generally a descriptive title for the image in question.
   */
  name?: string;

  /**
   * This is a boolean value that indicates whether the image in question is public
   * or not. An image that is public is available to all accounts. A non-public image
   * is only accessible from your account.
   */
  public?: boolean;

  /**
   * This attribute is an array of the regions that the image is available in. The
   * regions are represented by their identifying slug values.
   */
  regions?: Array<
    | 'ams1'
    | 'ams2'
    | 'ams3'
    | 'blr1'
    | 'fra1'
    | 'lon1'
    | 'nyc1'
    | 'nyc2'
    | 'nyc3'
    | 'sfo1'
    | 'sfo2'
    | 'sfo3'
    | 'sgp1'
    | 'tor1'
    | 'syd1'
  >;

  /**
   * The size of the image in gigabytes.
   */
  size_gigabytes?: number | null;

  /**
   * A uniquely identifying string that is associated with each of the
   * DigitalOcean-provided public images. These can be used to reference a public
   * image as an alternative to the numeric id.
   */
  slug?: string | null;

  /**
   * A status string indicating the state of a custom image. This may be `NEW`,
   * `available`, `pending`, `deleted`, or `retired`.
   */
  status?: 'NEW' | 'available' | 'pending' | 'deleted' | 'retired';

  /**
   * A flat array of tag names as strings to be applied to the resource. Tag names
   * may be for either existing or new tags.
   *
   * Requires `tag:create` scope.
   */
  tags?: Array<string> | null;

  /**
   * Describes the kind of image. It may be one of `base`, `snapshot`, `backup`,
   * `custom`, or `admin`. Respectively, this specifies whether an image is a
   * DigitalOcean base OS image, user-generated Droplet snapshot, automatically
   * created Droplet backup, user-provided virtual machine image, or an image used
   * for DigitalOcean managed resources (e.g. DOKS worker nodes).
   */
  type?: 'base' | 'snapshot' | 'backup' | 'custom' | 'admin';
}

/**
 * Emitted when image generation has completed and the final image is available.
 */
export interface ImageGenCompletedEvent {
  /**
   * Base64-encoded image data, suitable for rendering as an image.
   */
  b64_json: string;

  /**
   * The background setting for the generated image.
   */
  background: 'transparent' | 'opaque' | 'auto';

  /**
   * The Unix timestamp when the event was created.
   */
  created_at: number;

  /**
   * The output format for the generated image.
   */
  output_format: 'png' | 'webp' | 'jpeg';

  /**
   * The quality setting for the generated image.
   */
  quality: 'low' | 'medium' | 'high' | 'auto';

  /**
   * The size of the generated image.
   */
  size: '1024x1024' | '1024x1536' | '1536x1024' | 'auto';

  /**
   * The type of the event. Always `image_generation.completed`.
   */
  type: 'image_generation.completed';

  /**
   * For `gpt-image-1` only, the token usage information for the image generation.
   */
  usage: ImageGenCompletedEvent.Usage;
}

export namespace ImageGenCompletedEvent {
  /**
   * For `gpt-image-1` only, the token usage information for the image generation.
   */
  export interface Usage {
    /**
     * The number of tokens (images and text) in the input prompt.
     */
    input_tokens: number;

    /**
     * The input tokens detailed information for the image generation.
     */
    input_tokens_details: Usage.InputTokensDetails;

    /**
     * The number of image tokens in the output image.
     */
    output_tokens: number;

    /**
     * The total number of tokens (images and text) used for the image generation.
     */
    total_tokens: number;
  }

  export namespace Usage {
    /**
     * The input tokens detailed information for the image generation.
     */
    export interface InputTokensDetails {
      /**
       * The number of image tokens in the input prompt.
       */
      image_tokens: number;

      /**
       * The number of text tokens in the input prompt.
       */
      text_tokens: number;
    }
  }
}

/**
 * Emitted when a partial image is available during image generation streaming.
 */
export interface ImageGenPartialImageEvent {
  /**
   * Base64-encoded partial image data, suitable for rendering as an image.
   */
  b64_json: string;

  /**
   * The background setting for the requested image.
   */
  background: 'transparent' | 'opaque' | 'auto';

  /**
   * The Unix timestamp when the event was created.
   */
  created_at: number;

  /**
   * The output format for the requested image.
   */
  output_format: 'png' | 'webp' | 'jpeg';

  /**
   * 0-based index for the partial image (streaming).
   */
  partial_image_index: number;

  /**
   * The quality setting for the requested image.
   */
  quality: 'low' | 'medium' | 'high' | 'auto';

  /**
   * The size of the requested image.
   */
  size: '1024x1024' | '1024x1536' | '1536x1024' | 'auto';

  /**
   * The type of the event. Always `image_generation.partial_image`.
   */
  type: 'image_generation.partial_image';
}

/**
 * Emitted when a partial image is available during image generation streaming.
 */
export type ImageGenStreamEvent = ImageGenPartialImageEvent | ImageGenCompletedEvent;

/**
 * @deprecated **Note**: All Droplets created after March 2017 use internal kernels
 * by default. These Droplets will have this attribute set to `null`.
 *
 * The current
 * [kernel](https://docs.digitalocean.com/products/droplets/how-to/kernel/) for
 * Droplets with externally managed kernels. This will initially be set to the
 * kernel of the base image when the Droplet is created.
 */
export interface Kernel {
  /**
   * A unique number used to identify and reference a specific kernel.
   */
  id?: number;

  /**
   * The display name of the kernel. This is shown in the web UI and is generally a
   * descriptive title for the kernel in question.
   */
  name?: string;

  /**
   * A standard kernel version string representing the version, patch, and release
   * information.
   */
  version?: string;
}

/**
 * Information about the response itself.
 */
export interface MetaProperties {
  /**
   * Number of objects returned by the request.
   */
  total?: number;
}

export interface NetworkV4 {
  /**
   * The gateway of the specified IPv4 network interface.
   *
   * For private interfaces, a gateway is not provided. This is denoted by returning
   * `nil` as its value.
   */
  gateway?: string;

  /**
   * The IP address of the IPv4 network interface.
   */
  ip_address?: string;

  /**
   * The netmask of the IPv4 network interface.
   */
  netmask?: string;

  /**
   * The type of the IPv4 network interface.
   */
  type?: 'public' | 'private';
}

export interface NetworkV6 {
  /**
   * The gateway of the specified IPv6 network interface.
   */
  gateway?: string;

  /**
   * The IP address of the IPv6 network interface.
   */
  ip_address?: string;

  /**
   * The netmask of the IPv6 network interface.
   */
  netmask?: number;

  /**
   * The type of the IPv6 network interface.
   *
   * **Note**: IPv6 private networking is not currently supported.
   */
  type?: 'public';
}

export interface PageLinks {
  pages?: ForwardLinks | BackwardLinks | unknown;
}

export interface Region {
  /**
   * This is a boolean value that represents whether new Droplets can be created in
   * this region.
   */
  available: boolean;

  /**
   * This attribute is set to an array which contains features available in this
   * region
   */
  features: Array<string>;

  /**
   * The display name of the region. This will be a full name that is used in the
   * control panel and other interfaces.
   */
  name: string;

  /**
   * This attribute is set to an array which contains the identifying slugs for the
   * sizes available in this region. sizes:read is required to view.
   */
  sizes: Array<string>;

  /**
   * A human-readable string that is used as a unique identifier for each region.
   */
  slug: string;
}

export interface Size {
  /**
   * This is a boolean value that represents whether new Droplets can be created with
   * this size.
   */
  available: boolean;

  /**
   * A string describing the class of Droplets created from this size. For example:
   * Basic, General Purpose, CPU-Optimized, Memory-Optimized, or Storage-Optimized.
   */
  description: string;

  /**
   * The amount of disk space set aside for Droplets of this size. The value is
   * represented in gigabytes.
   */
  disk: number;

  /**
   * The amount of RAM allocated to Droplets created of this size. The value is
   * represented in megabytes.
   */
  memory: number;

  /**
   * This describes the price of the Droplet size as measured hourly. The value is
   * measured in US dollars.
   */
  price_hourly: number;

  /**
   * This attribute describes the monthly cost of this Droplet size if the Droplet is
   * kept for an entire month. The value is measured in US dollars.
   */
  price_monthly: number;

  /**
   * An array containing the region slugs where this size is available for Droplet
   * creates.
   */
  regions: Array<string>;

  /**
   * A human-readable string that is used to uniquely identify each size.
   */
  slug: string;

  /**
   * The amount of transfer bandwidth that is available for Droplets created in this
   * size. This only counts traffic on the public interface. The value is given in
   * terabytes.
   */
  transfer: number;

  /**
   * The number of CPUs allocated to Droplets of this size.
   */
  vcpus: number;

  /**
   * An array of objects containing information about the disks available to Droplets
   * created with this size.
   */
  disk_info?: Array<DiskInfo>;

  /**
   * An object containing information about the GPU capabilities of Droplets created
   * with this size.
   */
  gpu_info?: GPUInfo;
}

export interface Snapshots {
  /**
   * The unique identifier for the snapshot.
   */
  id: string;

  /**
   * A time value given in ISO8601 combined date and time format that represents when
   * the snapshot was created.
   */
  created_at: string;

  /**
   * The minimum size in GB required for a volume or Droplet to use this snapshot.
   */
  min_disk_size: number;

  /**
   * A human-readable name for the snapshot.
   */
  name: string;

  /**
   * An array of the regions that the snapshot is available in. The regions are
   * represented by their identifying slug values.
   */
  regions: Array<string>;

  /**
   * The unique identifier for the resource that the snapshot originated from.
   */
  resource_id: string;

  /**
   * The type of resource that the snapshot originated from.
   */
  resource_type: 'droplet' | 'volume';

  /**
   * The billable size of the snapshot in gigabytes.
   */
  size_gigabytes: number;

  /**
   * An array of Tags the snapshot has been tagged with.
   *
   * Requires `tag:read` scope.
   */
  tags: Array<string> | null;
}

export interface Subscription {
  /**
   * The time at which the subscription was created.
   */
  created_at?: string;

  tier?: SubscriptionTierBase;

  /**
   * The time at which the subscription was last updated.
   */
  updated_at?: string;
}

export interface SubscriptionTierBase {
  /**
   * A boolean indicating whether the subscription tier supports additional storage
   * above what is included in the base plan at an additional cost per GiB used.
   */
  allow_storage_overage?: boolean;

  /**
   * The amount of outbound data transfer included in the subscription tier in bytes.
   */
  included_bandwidth_bytes?: number;

  /**
   * The number of repositories included in the subscription tier. `0` indicates that
   * the subscription tier includes unlimited repositories.
   */
  included_repositories?: number;

  /**
   * The amount of storage included in the subscription tier in bytes.
   */
  included_storage_bytes?: number;

  /**
   * The monthly cost of the subscription tier in cents.
   */
  monthly_price_in_cents?: number;

  /**
   * The name of the subscription tier.
   */
  name?: string;

  /**
   * The slug identifier of the subscription tier.
   */
  slug?: string;

  /**
   * The price paid in cents per GiB for additional storage beyond what is included
   * in the subscription plan.
   */
  storage_overage_price_in_cents?: number;
}

export interface VpcPeering {
  /**
   * A unique ID that can be used to identify and reference the VPC peering.
   */
  id?: string;

  /**
   * A time value given in ISO8601 combined date and time format.
   */
  created_at?: string;

  /**
   * The name of the VPC peering. Must be unique within the team and may only contain
   * alphanumeric characters and dashes.
   */
  name?: string;

  /**
   * The current status of the VPC peering.
   */
  status?: 'PROVISIONING' | 'ACTIVE' | 'DELETING';

  /**
   * An array of the two peered VPCs IDs.
   */
  vpc_ids?: Array<string>;
}