import { SolidContainerSlug, SolidContainerUri, SolidLeafSlug } from "../types.cjs";
import { DeleteSuccess } from "../requester/results/success/DeleteSuccess.cjs";
import { CheckRootResult, CheckRootResultError } from "../requester/requests/checkRootContainer.cjs";
import { ContainerReadSuccess } from "../requester/results/success/SolidReadSuccess.cjs";
import { ReadContainerResult, ReadResultError } from "../requester/requests/readResource.cjs";
import { ContainerBatchedRequester } from "../requester/ContainerBatchedRequester.cjs";
import { NoRootContainerError } from "../requester/results/error/NoRootContainerError.cjs";
import { SharedStatuses, SolidResource } from "./SolidResource.cjs";
import { DeleteResult, DeleteResultError } from "../requester/requests/deleteResource.cjs";
import { ContainerCreateAndOverwriteResult, ContainerCreateIfAbsentResult, LeafCreateAndOverwriteResult, LeafCreateIfAbsentResult } from "../requester/requests/createDataResource.cjs";
import { SolidLeaf } from "./SolidLeaf.cjs";
import { SolidConnectedPlugin } from "../SolidConnectedPlugin.cjs";
import { AggregateError, AggregateSuccess, ConnectedContext, IgnoredInvalidUpdateSuccess, ReadSuccess } from "@ldo/connected";
import { DatasetChanges } from "@ldo/rdf-utils";

//#region src/resources/SolidContainer.d.ts
/**
 * Represents the current status of a specific container on a Pod as known by
 * LDO.
 *
 * @example
 * ```typescript
 * const container = solidLdoDataset
 *   .getResource("https://example.com/container/");
 * ```
 */
declare class SolidContainer extends SolidResource {
  /**
   * The URI of the container
   */
  readonly uri: SolidContainerUri;
  /**
   * @internal
   * Batched Requester for the Container
   */
  protected requester: ContainerBatchedRequester;
  /**
   * @internal
   * True if this is the root container, false if not, undefined if unknown
   */
  protected rootContainer: boolean | undefined;
  /**
   * Indicates that this resource is a container resource
   */
  readonly type: "SolidContainer";
  /**
   * Indicates that this resource is not an error
   */
  readonly isError: false;
  /**
   * The status of the last request made for this container
   */
  status: SharedStatuses<this> | ReadContainerResult | ContainerCreateAndOverwriteResult | ContainerCreateIfAbsentResult | CheckRootResult;
  /**
   * @param uri - The uri of the container
   * @param context - SolidLdoDatasetContext for the parent dataset
   */
  constructor(uri: SolidContainerUri, context: ConnectedContext<SolidConnectedPlugin[]>);
  /**
   * Checks if this container is a root container
   * @returns true if this container is a root container, false if not, and
   * undefined if this is unknown at the moment.
   *
   * @example
   * ```typescript
   * // Returns "undefined" when the container is unfetched
   * console.log(container.isRootContainer());
   * const result = await container.read();
   * if (!result.isError) {
   *   // Returns true or false
   *   console.log(container.isRootContainer());
   * }
   * ```
   */
  isRootContainer(): boolean | undefined;
  /**
   * ===========================================================================
   * READ METHODS
   * ===========================================================================
   */
  /**
   * @internal
   * A helper method updates this container's internal state upon read success
   * @param result - the result of the read success
   */
  protected updateWithReadSuccess(result: ReadSuccess<this> | ContainerReadSuccess): void;
  /**
   * Reads the container
   * @returns A read result
   *
   * @example
   * ```typescript
   * const result = await container.read();
   * if (result.isError) {
   *   // Do something
   * }
   * ```
   */
  read(): Promise<ReadContainerResult>;
  /**
   * @internal
   * Converts the current state of this container to a readResult
   * @returns a ReadContainerResult
   */
  protected toReadResult(): ReadContainerResult;
  /**
   * Makes a request to read this container if it hasn't been fetched yet. If it
   * has, return the cached informtation
   * @returns a ReadContainerResult
   *
   * @example
   * ```typescript
   * const result = await container.read();
   * if (!result.isError) {
   *   // Will execute without making a request
   *   const result2 = await container.readIfUnfetched();
   * }
   * ```
   */
  readIfUnfetched(): Promise<ReadContainerResult>;
  /**
   * ===========================================================================
   * PARENT CONTAINER METHODS
   * ===========================================================================
   */
  /**
   * @internal
   * Checks if this container is a root container by making a request
   * @returns CheckRootResult
   */
  private checkIfIsRootContainer;
  /**
   * Gets the root container of this container. If this container is the root
   * container, this function returns itself.
   *
   * Consider getRootContainer() instead, which tries multiple discovery strategies.
   *
   * @returns The root container for this container or undefined if there is no
   * root container.
   *
   * @example
   * Suppose the root container is at `https://example.com/`
   *
   * ```typescript
   * const container = ldoSolidDataset
   *   .getResource("https://example.com/container/");
   * const rootContainer = await container.getRootContainerByTraversal();
   * if (!rootContainer.isError) {
   *   // logs "https://example.com/"
   *   console.log(rootContainer.uri);
   * }
   * ```
   */
  getRootContainerByTraversal(): Promise<SolidContainer | CheckRootResultError | NoRootContainerError<SolidContainer>>;
  /**
   * Gets the parent container for this container by making a request
   * @returns The parent container or undefined if there is no parent container
   * because this container is the root container
   *
   * @example
   * Suppose the root container is at `https://example.com/`
   *
   * ```typescript
   * const root = solidLdoDataset.getResource("https://example.com/");
   * const container = solidLdoDataset
   *   .getResource("https://example.com/container");
   * const rootParent = await root.getParentContainer();
   * console.log(rootParent); // Logs "undefined"
   * const containerParent = await container.getParentContainer();
   * if (!containerParent.isError) {
   *   // Logs "https://example.com/"
   *   console.log(containerParent.uri);
   * }
   * ```
   */
  getParentContainer(): Promise<SolidContainer | CheckRootResultError | undefined>;
  /**
   * Lists the currently cached children of this container (no request is made)
   * @returns An array of children
   *
   * ```typescript
   * const result = await container.read();
   * if (!result.isError) {
   *   const children = container.children();
   *   children.forEach((child) => {
   *     console.log(child.uri);
   *   });
   * }
   * ```
   */
  children(): (SolidContainer | SolidLeaf)[];
  /**
   * Returns a child resource with a given name (slug)
   * @param slug - the given name for that child resource
   * @returns the child resource (either a Leaf or Container depending on the
   * name)
   *
   * @example
   * ```typescript
   * const root = solidLdoDataset.getResource("https://example.com/");
   * const container = solidLdoDataset.child("container/");
   * // Logs "https://example.com/container/"
   * console.log(container.uri);
   * const resource = container.child("resource.ttl");
   * // Logs "https://example.com/container/resource.ttl"
   * console.log(resource.uri);
   * ```
   */
  child(slug: SolidContainerSlug): SolidContainer;
  child(slug: SolidLeafSlug): SolidLeaf;
  child(slug: string): SolidLeaf | SolidContainer;
  /**
   * ===========================================================================
   * CHILD CREATORS
   * ===========================================================================
   */
  /**
   * Creates a resource and overwrites any existing resource that existed at the
   * URI
   *
   * @param slug - the name of the resource
   * @return the result of creating that resource
   *
   * @example
   * ```typescript
   * const container = solidLdoDataset
   *   .getResource("https://example.com/container/");
   * cosnt result = await container.createChildAndOverwrite("resource.ttl");
   * if (!result.isError) {
   *   // Do something
   * }
   * ```
   */
  createChildAndOverwrite(slug: SolidContainerSlug): Promise<ContainerCreateAndOverwriteResult>;
  createChildAndOverwrite(slug: SolidLeafSlug): Promise<LeafCreateAndOverwriteResult>;
  createChildAndOverwrite(slug: string): Promise<ContainerCreateAndOverwriteResult | LeafCreateAndOverwriteResult>;
  /**
   * Creates a resource only if that resource doesn't already exist on the Solid
   * Pod
   *
   * @param slug - the name of the resource
   * @return the result of creating that resource
   *
   * @example
   * ```typescript
   * const container = solidLdoDataset
   *   .getResource("https://example.com/container/");
   * cosnt result = await container.createChildIfAbsent("resource.ttl");
   * if (!result.isError) {
   *   // Do something
   * }
   * ```
   */
  createChildIfAbsent(slug: SolidContainerSlug): Promise<ContainerCreateIfAbsentResult>;
  createChildIfAbsent(slug: SolidLeafSlug): Promise<LeafCreateIfAbsentResult>;
  createChildIfAbsent(slug: string): Promise<ContainerCreateIfAbsentResult | LeafCreateIfAbsentResult>;
  /**
   * Creates a new binary resource and overwrites any existing resource that
   * existed at the URI
   *
   * @param slug - the name of the resource
   * @return the result of creating that resource
   *
   * @example
   * ```typescript
   * const container = solidLdoDataset
   *   .getResource("https://example.com/container/");
   * cosnt result = await container.uploadChildAndOverwrite(
   *   "resource.txt",
   *   new Blob("some text."),
   *   "text/txt",
   * );
   * if (!result.isError) {
   *   // Do something
   * }
   * ```
   */
  uploadChildAndOverwrite(slug: SolidLeafSlug, blob: Blob, mimeType: string): Promise<LeafCreateAndOverwriteResult>;
  /**
   * Creates a new binary resource and overwrites any existing resource that
   * existed at the URI
   *
   * @param slug - the name of the resource
   * @return the result of creating that resource
   *
   * @example
   * ```typescript
   * const container = solidLdoDataset
   *   .getResource("https://example.com/container/");
   * cosnt result = await container.uploadChildIfAbsent(
   *   "resource.txt",
   *   new Blob("some text."),
   *   "text/txt",
   * );
   * if (!result.isError) {
   *   // Do something
   * }
   * ```
   */
  uploadChildIfAbsent(slug: SolidLeafSlug, blob: Blob, mimeType: string): Promise<LeafCreateIfAbsentResult>;
  /**
   * Deletes all contents in this container
   * @returns An AggregateSuccess or Aggregate error corresponding with all the
   * deleted resources
   *
   * @example
   * ```typescript
   * const result = container.clear();
   * if (!result.isError) {
   *   console.log("All deleted resources:");
   *   result.results.forEach((result) => console.log(result.uri));
   * }
   * ```
   */
  clear(): Promise<AggregateSuccess<DeleteSuccess<SolidContainer | SolidLeaf>> | AggregateError<DeleteResultError<SolidContainer | SolidLeaf> | ReadResultError<SolidContainer | SolidLeaf>>>;
  /**
   * Deletes this container and all its contents
   * @returns A Delete result for this container
   *
   * ```typescript
   * const result = await container.delete();
   * if (!result.isError) {
   *   // Do something
   * }
   * ```
   */
  delete(): Promise<DeleteResult<this> | AggregateError<DeleteResultError<SolidContainer | SolidLeaf> | ReadResultError<SolidContainer | SolidLeaf>>>;
  protected handleDelete(): Promise<DeleteResult<this>>;
  /**
   * Creates a container at this URI and overwrites any that already exists
   * @returns ContainerCreateAndOverwriteResult
   *
   * @example
   * ```typescript
   * const result = await container.createAndOverwrite();
   * if (!result.isError) {
   *   // Do something
   * }
   * ```
   */
  createAndOverwrite(): Promise<ContainerCreateAndOverwriteResult>;
  /**
   * Creates a container at this URI if the container doesn't already exist
   * @returns ContainerCreateIfAbsentResult
   *
   * @example
   * ```typescript
   * const result = await container.createIfAbsent();
   * if (!result.isError) {
   *   // Do something
   * }
   * ```
   */
  createIfAbsent(): Promise<ContainerCreateIfAbsentResult>;
  /**
   * You cannot update a Container, so we return an IgnoredInvalidUpdateSuccess
   */
  update(_datasetChanges: DatasetChanges): Promise<IgnoredInvalidUpdateSuccess<this>>;
}
//#endregion
export { SolidContainer };
//# sourceMappingURL=SolidContainer.d.cts.map