Additional Runtime APIs

import { generateIdempotencyKey } from "@golemcloud/golem-ts-sdk";
 
const key = generateIdempotencyKey();

import { Effect } from "effect"
import { Durability } from "@golemcloud/effect-golem"
 
const key = Effect.gen(function* () {
  return yield* Durability.generateIdempotencyKey
})

use golem_rust::generate_idempotency_key;
 
let key = generate_idempotency_key();

import golem.HostApi
 
val key = HostApi.generateIdempotencyKey()

let key = @api.generate_idempotency_key()

/**
 * Metadata about an agent
 */
export type AgentMetadata = {
  /** The agent ID, consists of the component ID, agent type and agent parameters */
  agentId: AgentId;
  /** Command line arguments seen by the agent */
  args: string[];
  /** Environment variables seen by the agent */
  env: [string, string][];
  /** Configuration variables seen by the agent */
  config: [string, string][];
  /** The current agent status */
  status: AgentStatus;
  /** The component revision the agent is running with */
  componentRevision: bigint;
  /** The agent's current retry count */
  retryCount: bigint;
  /** The environment the agent belongs to */
  environmentId: EnvironmentId;
};

import { Agents } from "@golemcloud/effect-golem"
 
const self = Agents.getSelfMetadata
const other = (agentId: Agents.AgentId) => Agents.getAgentMetadata(agentId)

/// Metadata about an agent
pub struct AgentMetadata {
  /// The agent ID, consists of the component ID, agent type and agent parameters
  pub agent_id: AgentId,
  /// Command line arguments seen by the agent
  pub args: Vec<String>,
  /// Environment variables seen by the agent
  pub env: Vec<(String, String)>,
  /// Configuration variables seen by the agent
  pub config: Vec<(String, String)>,
  /// The current agent status
  pub status: AgentStatus,
  /// The component revision the agent is running with
  pub component_revision: u64,
  /// The agent's current retry count
  pub retry_count: u64,
  /// The environment the agent belongs to
  pub environment_id: EnvironmentId,
}

import golem.HostApi
import golem.host.js.JsEnvironmentId
 
final case class AgentMetadata(
  agentId: HostApi.AgentIdLiteral,
  args: List[String],
  env: Map[String, String],
  config: Map[String, String],
  status: HostApi.AgentStatus,
  componentRevision: BigInt,
  retryCount: BigInt,
  agentType: String,
  agentName: String,
  componentId: HostApi.ComponentIdLiteral,
  environmentId: JsEnvironmentId
)

/// Metadata about an agent
pub(all) struct AgentMetadata {
  agent_id : @rpcTypes.AgentId
  args : Array[String]
  env : Array[(String, String)]
  config : Array[(String, String)]
  status : @api.AgentStatus
  component_revision : UInt64
  retry_count : UInt64
  environment_id : @api.EnvironmentId
}

import {
  ComponentId,
  GetAgents,
  AgentAnyFilter,
  AgentMetadata,
  AgentStatusFilter,
} from "golem:api/host@1.5.0"
 
const filter: AgentAnyFilter = {
  filters: [
    {
      filters: [
        {
          tag: "status",
          val: {
            comparator: "equal",
            value: "idle",
          } satisfies AgentStatusFilter,
        },
      ],
    },
  ],
}
 
const componentId: ComponentId = {
  /* ... */
}
const agents: AgentMetadata[] = []
const getter = new GetAgents(componentId, filter, true)
 
let batch: AgentMetadata[] | undefined
while ((batch = getter.getNext()) !== undefined) {
  agents.push(...batch)
}

import { Stream } from "effect"
import { Agents } from "@golemcloud/effect-golem"
 
const enumerateAgents = (componentId: Agents.ComponentId) =>
  Agents.getAgents({ componentId, precise: true }).pipe(Stream.runCollect)

use golem_rust::{
    AgentAllFilter, AgentAnyFilter, AgentMetadata, AgentPropertyFilter, AgentStatus,
    AgentStatusFilter, ComponentId, FilterComparator, GetAgents,
};
 
let component_id: ComponentId = /* ... */;
 
let filter = AgentAnyFilter {
    filters: vec![AgentAllFilter {
        filters: vec![AgentPropertyFilter::Status(AgentStatusFilter {
            comparator: FilterComparator::Equal,
            value: AgentStatus::Idle,
        })],
    }],
};
 
let getter = GetAgents::new(component_id, Some(&filter), true);
 
let mut agents: Vec<AgentMetadata> = vec![];
 
while let Some(batch) = getter.get_next()? {
    agents.extend(batch);
}

import golem.HostApi
 
val filter: HostApi.AgentAnyFilter = HostApi.AgentAnyFilter(
  List(
    HostApi.AgentAllFilter(
      List(
        HostApi.AgentPropertyFilter.status(
          HostApi.AgentStatusFilter(HostApi.FilterComparator.Equal, HostApi.AgentStatus.Idle)
        )
      )
    )
  )
)
 
val componentId: HostApi.ComponentIdLiteral = ???
val handle = HostApi.getAgents(componentId, Some(filter), precise = true)
 
var agents: List[HostApi.AgentMetadata] = Nil
var batch = HostApi.nextAgentBatch(handle)
 
while (batch.isDefined) {
  agents = agents ++ batch.get
  batch = HostApi.nextAgentBatch(handle)
}

let filter : @api.AgentAnyFilter = @api.AgentAnyFilter::{
  filters: [
    @api.AgentAllFilter::{
      filters: [
        @api.AgentPropertyFilter::Status(@api.AgentStatusFilter::{
          comparator: @api.FilterComparator::EQUAL,
          value: @api.AgentStatus::IDLE,
        }),
      ],
    },
  ],
}
 
let component_id : @rpcTypes.ComponentId = abort("provide a component ID")
let agents : Array[@api.AgentMetadata] = []
let pager = @api.get_agents(component_id, Some(filter), true)
defer pager.drop()
 
while true {
  match pager.next_page() {
    Some(batch) => agents.append(batch)
    None => break
  }
}

import {
  getSelfMetadata,
  updateAgent,
  type AgentId,
  type ComponentRevision,
} from "golem:api/host@1.5.0"
 
const agentId: AgentId = getSelfMetadata().agentId
 
const targetRevision: ComponentRevision = 1n
 
updateAgent(agentId, targetRevision, "automatic")

import { Effect } from "effect"
import { Agents } from "@golemcloud/effect-golem"
 
const updateSelf = Effect.gen(function* () {
  const metadata = yield* Agents.getSelfMetadata
  yield* Agents.updateAgent({
    agentId: metadata.agentId,
    targetRevision: 1n,
    mode: "automatic",
  })
})

use golem_rust::{get_self_metadata, update_agent, UpdateMode};
 
let agent_id = get_self_metadata()?.agent_id;
let target_component_revision = 1u64;
 
update_agent(&agent_id, target_component_revision, UpdateMode::Automatic)?;

import golem.HostApi
 
val agentId = HostApi.getSelfMetadata().agentId
val targetRevision = BigInt(1)
 
HostApi.updateAgent(agentId, targetRevision, HostApi.UpdateMode.Automatic)

let agent_id = @api.get_self_metadata().agent_id
let target_revision : UInt64 = 1
 
@api.update_agent(agent_id, target_revision, @api.UpdateMode::AUTOMATIC)

/**
 * Invocation context support
 */
declare module 'golem:api/context@1.5.0' {
  /**
   * Gets the current invocation context
   * The function call captures the current context; if new spans are started, the returned `invocation-context` instance will not
   * reflect that.
   */
  export function currentContext(): InvocationContext;
}

/**
 * Starts a new `span` with the given name, as a child of the current invocation context
 */
export function startSpan(name: string): Span;

import { Effect } from "effect"
import { Tracing } from "@golemcloud/effect-golem"
 
const operation = Effect.gen(function* () {
  const context = yield* Tracing.currentContext
  return context.traceId
}).pipe(Effect.withSpan("my-operation"))

/**
 * Invocation context support
 */
pub fn current_context() -> InvocationContext;

/**
 * Starts a new `span` with the given name, as a child of the current invocation context
 */
pub fn start_span(name: &str) -> Span

import golem.host.ContextApi
 
def currentContext(): ContextApi.InvocationContext

import golem.host.ContextApi
 
def startSpan(name: String): ContextApi.Span

/// Gets the current invocation context
///
/// The function call captures the current context; if new spans are started, the returned `invocation-context` instance will not
/// reflect that.
pub fn current_context() -> InvocationContext

/// Starts a new `span` with the given name, as a child of the current invocation context
pub fn start_span(name : String) -> Span

/**
* Get the value associated with the key in the bucket.
* The value is returned as an option. If the key-value pair exists in the
* bucket, it returns `Ok(value)`. If the key does not exist in the
* bucket, it returns `Ok(none)`.
* If any other error occurs, it returns an `Err(error)`.
* @throws Error
*/
export function get(bucket: Bucket, key: Key): IncomingValue | undefined;
/**
* Set the value associated with the key in the bucket. If the key already
* exists in the bucket, it overwrites the value.
* If the key does not exist in the bucket, it creates a new key-value pair.
* If any other error occurs, it returns an `Err(error)`.
* @throws Error
*/
export function set(bucket: Bucket, key: Key, outgoingValue: OutgoingValue): void;
/**
* Delete the key-value pair associated with the key in the bucket.
* If the key does not exist in the bucket, it does nothing.
* If any other error occurs, it returns an `Err(error)`.
* @throws Error
*/
export function delete_(bucket: Bucket, key: Key): void;
/**
* Check if the key exists in the bucket.
* If the key exists in the bucket, it returns `Ok(true)`. If the key does
* not exist in the bucket, it returns `Ok(false)`.
* If any other error occurs, it returns an `Err(error)`.
* @throws Error
*/
export function exists(bucket: Bucket, key: Key): boolean;

export class OutgoingValue {
    static newOutgoingValue(): OutgoingValue;
    outgoingValueWriteBodyAsync(data: AsyncIterable<number>): void;
    outgoingValueWriteBodySync(value: Uint8Array): void;
}
 
export class IncomingValue {
    incomingValueConsumeSync(): Uint8Array;
    incomingValueConsumeAsync(): AsyncIterable<number>;
    incomingValueSize(): bigint;
}

import { Effect, Option } from "effect"
import { KeyValue } from "@golemcloud/effect-golem"
 
const program = Effect.scoped(
  Effect.gen(function* () {
    const bucket = yield* KeyValue.openBucket("shared")
    yield* bucket.set("greeting", new TextEncoder().encode("hello"))
    const value = yield* bucket.get("greeting")
    return Option.map(value, (bytes) => new TextDecoder().decode(bytes))
  }),
)

/**
* Get the value associated with the key in the bucket.
* The value is returned as an option. If the key-value pair exists in the
* bucket, it returns `Ok(value)`. If the key does not exist in the
* bucket, it returns `Ok(none)`.
* If any other error occurs, it returns an `Err(error)`.
* @throws Error
*/
pub fn get(bucket: &Bucket, key: &str) -> Result<Option<IncomingValue>, Error>;
/**
* Set the value associated with the key in the bucket. If the key already
* exists in the bucket, it overwrites the value.
* If the key does not exist in the bucket, it creates a new key-value pair.
* If any other error occurs, it returns an `Err(error)`.
* @throws Error
*/
pub fn set(bucket: &Bucket, key: &str, outgoing_value: &OutgoingValue) -> Result<(), Error>;
/**
* Delete the key-value pair associated with the key in the bucket.
* If the key does not exist in the bucket, it does nothing.
* If any other error occurs, it returns an `Err(error)`.
* @throws Error
*/
pub fn delete(bucket: &Bucket, key: &str) -> Result<(), Error>;
/**
* Check if the key exists in the bucket.
* If the key exists in the bucket, it returns `Ok(true)`. If the key does
* not exist in the bucket, it returns `Ok(false)`.
* If any other error occurs, it returns an `Err(error)`.
* @throws Error
*/
pub fn exists(bucket: &Bucket, key: &str) -> Result<bool, Error>;

impl OutgoingValue {
    pub fn new_outgoing_value() -> OutgoingValue;
    /**
     * Writes the value asynchronously by consuming the given `stream<u8>`:
     * the caller keeps the writable end and the host appends every received
     * byte to the outgoing value's body.
     * If any other error occurs, it returns an `Err(error)`.
     * @throws Error
     */
    pub fn outgoing_value_write_body_async(&self, data: StreamReader<u8>) -> Result<(), Error>;
    /**
     * Writes the value to the output-stream synchronously.
     * If any other error occurs, it returns an `Err(error)`.
     * @throws Error
     */
    pub fn outgoing_value_write_body_sync(&self, value: &[u8]) -> Result<(), Error>;
}
 
 
impl IncomingValue {
    /**
     * Consumes the value synchronously and returns the value as a list of bytes.
     * If any other error occurs, it returns an `Err(error)`.
     * @throws Error
     */
    pub fn incoming_value_consume_sync(&self) -> Result<Vec<u8>, Error>;
    /**
     * Consumes the value asynchronously and returns the value as an `input-stream`.
     * If any other error occurs, it returns an `Err(error)`.
     * @throws Error
     */
    pub fn incoming_value_consume_async(&self) -> Result<StreamReader<u8>, Error>;
    /**
     * The size of the value in bytes.
     * If the size is unknown or unavailable, this function returns an `Err(error)`.
     * @throws Error
     */
    pub fn incoming_value_size(&self) -> Result<u64, Error>;
}
 

import golem.wasi.KeyValue
 
object KeyValue {
  object Bucket {
    def open(name: String): Bucket
  }
 
  final class Bucket {
    def get(key: String): Option[Array[Byte]]
    def set(key: String, value: Array[Byte]): Unit
    def delete(key: String): Unit
    def exists(key: String): Boolean
  }
}

import golem.wasi.KeyValue
 
object KeyValue {
  final class Bucket {
    def keys(): List[String]
    def getMany(keys: List[String]): List[Option[Array[Byte]]]
    def deleteMany(keys: List[String]): Unit
  }
}

import golem.wasi.KeyValue
 
object KeyValue {
  final class OutgoingValue {
    def writeSync(data: Array[Byte]): Unit
  }
 
  object OutgoingValue {
    def create(): OutgoingValue
  }
 
  final class IncomingValue {
    def consumeSync(): Array[Byte]
    def size(): Long
  }
 
  def eventualRaw: Any
  def eventualBatchRaw: Any
  def typesRaw: Any
}

/// Get the value associated with the key in the bucket.
/// The value is returned as an option. If the key-value pair exists in the
/// bucket, it returns `Ok(value)`. If the key does not exist in the
/// bucket, it returns `Ok(none)`.
/// If any other error occurs, it returns an `Err(error)`.
pub fn get(
  bucket : @types.Bucket,
  key : String,
) -> Result[@types.IncomingValue?, @wasiKeyvalueError.Error_]
 
/// Set the value associated with the key in the bucket. If the key already
/// exists in the bucket, it overwrites the value.
/// If the key does not exist in the bucket, it creates a new key-value pair.
/// If any other error occurs, it returns an `Err(error)`.
pub fn set(
  bucket : @types.Bucket,
  key : String,
  outgoing_value : @types.OutgoingValue,
) -> Result[Unit, @wasiKeyvalueError.Error_]
 
/// Delete the key-value pair associated with the key in the bucket.
/// If the key does not exist in the bucket, it does nothing.
/// If any other error occurs, it returns an `Err(error)`.
pub fn delete(
  bucket : @types.Bucket,
  key : String,
) -> Result[Unit, @wasiKeyvalueError.Error_]
 
/// Check if the key exists in the bucket.
/// If the key exists in the bucket, it returns `Ok(true)`. If the key does
/// not exist in the bucket, it returns `Ok(false)`.
/// If any other error occurs, it returns an `Err(error)`.
pub fn exists(
  bucket : @types.Bucket,
  key : String,
) -> Result[Bool, @wasiKeyvalueError.Error_]

pub fn Bucket::open_bucket(String) -> Result[Self, @wasiKeyvalueError.Error_]
 
pub(all) struct OutgoingValue(Int)
pub fn OutgoingValue::new_outgoing_value() -> Self
pub fn OutgoingValue::outgoing_value_write_body_sync(
  Self,
  FixedArray[Byte],
) -> Result[Unit, @wasiKeyvalueError.Error_]
pub fn OutgoingValue::outgoing_value_write_body_async(
  Self,
  @async-core.Stream[Byte],
) -> Result[Unit, @wasiKeyvalueError.Error_]
 
pub(all) struct IncomingValue(Int)
pub fn IncomingValue::incoming_value_consume_sync(
  Self,
) -> Result[FixedArray[Byte], @wasiKeyvalueError.Error_]
pub fn IncomingValue::incoming_value_consume_async(
  Self,
) -> Result[@async-core.Stream[Byte], @wasiKeyvalueError.Error_]
pub fn IncomingValue::incoming_value_size(
  Self,
) -> Result[UInt64, @wasiKeyvalueError.Error_]

declare module 'wasi:blobstore/blobstore' {
    /**
     * creates a new empty container
     * @throws Error
     */
    export function createContainer(name: ContainerName): Container;
    /**
     * retrieves a container by name
     * @throws Error
     */
    export function getContainer(name: ContainerName): Container;
    /**
     * deletes a container and all objects within it
     * @throws Error
     */
    export function deleteContainer(name: ContainerName): void;
    /**
     * returns true if the container exists
     * @throws Error
     */
    export function containerExists(name: ContainerName): boolean;
    /**
     * copies (duplicates) an object, to the same or a different container.
     * returns an error if the target container does not exist.
     * overwrites destination object if it already existed.
     * @throws Error
     */
    export function copyObject(src: ObjectId, dest: ObjectId): void;
    /**
     * moves or renames an object, to the same or a different container
     * returns an error if the destination container does not exist.
     * overwrites destination object if it already existed.
     * @throws Error
     */
    export function moveObject(src: ObjectId, dest: ObjectId): void;
 
    // ...
}

export class Container {
    /**
     * returns container name
     * @throws Error
     */
    name(): string;
    /**
     * returns container metadata
     * @throws Error
     */
    info(): ContainerMetadata;
    /**
     * retrieves an object or portion of an object, as a resource.
     * Start and end offsets are inclusive.
     * Once a data-blob resource has been created, the underlying bytes are held by the blobstore service for the lifetime
     * of the data-blob resource, even if the object they came from is later deleted.
     * @throws Error
     */
    getData(name: ObjectName, start: bigint, end: bigint): IncomingValue;
    /**
     * creates or replaces an object with the data blob.
     * @throws Error
     */
    writeData(name: ObjectName, data: OutgoingValue): void;
    /**
     * returns list of objects in the container. Order is undefined.
     * @throws Error
     */
    listObjects(): AsyncIterable<ObjectName>;
    /**
     * deletes object.
     * does not return error if object did not exist.
     * @throws Error
     */
    deleteObject(name: ObjectName): void;
    /**
     * deletes multiple objects in the container
     * @throws Error
     */
    deleteObjects(names: ObjectName[]): void;
    /**
     * returns true if the object exists in this container
     * @throws Error
     */
    hasObject(name: ObjectName): boolean;
    /**
     * returns metadata for the object
     * @throws Error
     */
    objectInfo(name: ObjectName): ObjectMetadata;
    /**
     * removes all objects within the container, leaving the container empty.
     * @throws Error
     */
    clear(): void;
}

import { Effect } from "effect"
import { Blobstore } from "@golemcloud/effect-golem"
 
const program = Effect.scoped(
  Effect.gen(function* () {
    const container = yield* Blobstore.getOrCreateContainer("documents")
    yield* container.writeData("hello.txt", new TextEncoder().encode("hello"))
    return yield* container.getData("hello.txt")
  }),
)

   /**
    * creates a new empty container
    */
   pub fn create_container(name: &str) -> Result<Container, Error>
   /**
    * retrieves a container by name
    */
   pub fn get_container(name: &str) -> Result<Container, Error>
   /**
    * deletes a container and all objects within it
    */
   pub fn delete_container(name: &str) -> Result<(), Error>
   /**
    * returns true if the container exists
    */
   pub fn container_exists(name: &str) -> Result<bool, Error>
   /**
    * copies (duplicates) an object, to the same or a different container.
    * returns an error if the target container does not exist.
    * overwrites destination object if it already existed.
    */
   pub fn copy_object(src: &ObjectId, dest: &ObjectId) -> Result<(), Error>
   /**
    * moves or renames an object, to the same or a different container
    * returns an error if the destination container does not exist.
    * overwrites destination object if it already existed.
    */
   pub fn move_object(src: &ObjectId, dest: &ObjectId) -> Result<(), Error>

impl Container {
    /**
     * returns container name
     */
    pub fn name(&self) -> Result<String, Error>
    /**
     * returns container metadata
     */
    pub fn info(&self) -> Result<ContainerMetadata, Error>
    /**
     * retrieves an object or portion of an object, as a resource.
     * Start and end offsets are inclusive.
     * Once a data-blob resource has been created, the underlying bytes are held by the blobstore service for the lifetime
     * of the data-blob resource, even if the object they came from is later deleted.
     */
    pub fn get_data(&self, name: &str, start: u64, end: u64) -> Result<IncomingValue, Error>
    /**
     * creates or replaces an object with the data blob.
     */
    pub fn write_data(&self, name: &str, data: &OutgoingValue) -> Result<(), Error>
    /**
     * returns list of objects in the container. Order is undefined.
     */
    pub fn list_objects(&self) -> Result<StreamReader<String>, Error>
    /**
     * deletes object.
     * does not return error if object did not exist.
     */
    pub fn delete_object(&self, name: &str) -> Result<(), Error>
    /**
     * deletes multiple objects in the container
     */
    pub fn delete_objects(&self, names: &[ObjectName]) -> Result<(), Error>
    /**
     * returns true if the object exists in this container
     */
    pub fn has_object(&self, name: &str) -> Result<bool, Error>
    /**
     * returns metadata for the object
     */
    pub fn object_info(&self, name: &str) -> Result<ObjectMetadata, Error>
    /**
     * removes all objects within the container, leaving the container empty.
     */
    pub fn clear(&self) -> Result<(), Error>
}

import golem.wasi.Blobstore
import scala.concurrent.Future
 
object Blobstore {
  final case class ObjectId(container: String, name: String)
 
  def createContainer(name: String): Container
  def getContainer(name: String): Container
  def deleteContainer(name: String): Unit
  def containerExists(name: String): Boolean
  def copyObject(src: ObjectId, dest: ObjectId): Unit
  def moveObject(src: ObjectId, dest: ObjectId): Unit
}

import golem.wasi.Blobstore
import scala.concurrent.Future
 
object Blobstore {
  final class Container {
    def name(): String
    def info(): ContainerMetadata
    def getData(objectName: String, start: Long, end: Long): Array[Byte]
    def writeData(objectName: String, data: Array[Byte]): Unit
    def listObjects(): Future[List[String]]
    def deleteObject(name: String): Unit
    def deleteObjects(names: List[String]): Unit
    def hasObject(name: String): Boolean
    def objectInfo(name: String): ObjectMetadata
    def clear(): Unit
  }
}

/// creates a new empty container
pub fn create_container(name : String) -> Result[@container.Container, String]
 
/// retrieves a container by name
pub fn get_container(name : String) -> Result[@container.Container, String]
 
/// deletes a container and all objects within it
pub fn delete_container(name : String) -> Result[Unit, String]
 
/// returns true if the container exists
pub fn container_exists(name : String) -> Result[Bool, String]
 
/// copies (duplicates) an object, to the same or a different container.
/// returns an error if the target container does not exist.
/// overwrites destination object if it already existed.
pub fn copy_object(
  src : @types.ObjectId,
  dest : @types.ObjectId,
) -> Result[Unit, String]
 
/// moves or renames an object, to the same or a different container
/// returns an error if the destination container does not exist.
/// overwrites destination object if it already existed.
pub fn move_object(
  src : @types.ObjectId,
  dest : @types.ObjectId,
) -> Result[Unit, String]
 
// ...

pub(all) struct Container(Int)
 
/// returns container name
pub fn Container::name(self : Container) -> Result[String, String]
 
/// returns container metadata
pub fn Container::info(self : Container) -> Result[@types.ContainerMetadata, String]
 
/// retrieves an object or portion of an object, as a resource.
/// Start and end offsets are inclusive.
/// Once a data-blob resource has been created, the underlying bytes are held by the blobstore service for the lifetime
/// of the data-blob resource, even if the object they came from is later deleted.
pub fn Container::get_data(
  self : Container,
  name : String,
  start : UInt64,
  end : UInt64,
) -> Result[@types.IncomingValue, String]
 
/// creates or replaces an object with the data blob.
pub fn Container::write_data(
  self : Container,
  name : String,
  data : @types.OutgoingValue,
) -> Result[Unit, String]
 
/// returns list of objects in the container. Order is undefined.
pub fn Container::list_objects(self : Container) -> Result[@async-core.Stream[String], String]
 
/// deletes object.
/// does not return error if object did not exist.
pub fn Container::delete_object(self : Container, name : String) -> Result[Unit, String]
 
/// deletes multiple objects in the container
pub fn Container::delete_objects(
  self : Container,
  names : Array[String],
) -> Result[Unit, String]
 
/// returns true if the object exists in this container
pub fn Container::has_object(self : Container, name : String) -> Result[Bool, String]
 
/// returns metadata for the object
pub fn Container::object_info(
  self : Container,
  name : String,
) -> Result[@types.ObjectMetadata, String]
 
/// removes all objects within the container, leaving the container empty.
pub fn Container::clear(self : Container) -> Result[Unit, String]