@interop/was-client 0.99.1 → 0.100.1

package/dist/WasClient.d.ts

@@ -9,6 +9,19 @@
  * (`grant`), capability-rebuilding (`fromCapability`), the signed
  * escape-hatch (`request`), and service discovery (`service`), which every
  * signed request waits on.
+ *
+ * A server that addresses Spaces by id is identified by its base server URL,
+ * under which the spec's Server Layout fixes `{base}service`, `{base}spaces/`
+ * and `{base}space/{space_id}/`. The client is built from that base
+ * (`new WasClient({ baseServerUrl })`) and constructs the three itself;
+ * `space(id)` opens a Space by id. A Space URL the client is handed (the
+ * `Location` of the create response, a capability's target, a DID, a stored
+ * pointer) is authoritative as given: `spaceAt(url)` opens it, and nothing
+ * rewrites it to fit the base. A server that is one fixed Space, with no id
+ * and no base server URL, is opened from the Space URL alone
+ * (`WasClient.forSpace({ spaceUrl })`); that client finds the service
+ * description through the `service` link and refuses the id-addressed
+ * operations.
  */
 import type { ZcapClient } from '@interop/ezcap';
 import type { HttpResponse } from '@interop/http-client';
@@ -18,32 +31,36 @@ import { Space } from './Space.js';
 import { Collection } from './Collection.js';
 import { Resource } from './Resource.js';
 import type { EncryptionOverride, GrantOptions, HandleOptions, IDelegatedZcap, ISigner, IZcap, Json, RequestInput, CollectionResourcesList, ResourceSummary, ServiceInfo, SpaceListing } from './types.js';
+/**
+ * The module-private key under which {@link WasClient.forSpace} hands the
+ * constructor a Space URL in place of a base server URL. A `unique symbol`
+ * keeps that arm off the public constructor: a caller holding a Space URL goes
+ * through `forSpace`, which documents what such a client can and cannot do.
+ */
+declare const fixedSpace: unique symbol;
 export declare class WasClient {
     #private;
     /**
-     * The server's Spaces Repository URL, in canonical trailing-slash form
-     * (`https://host/spaces/`). Service discovery starts here.
+     * The base server URL the client was built from, in canonical form
+     * (trailing slash supplied): the URL under which the server lays out
+     * `service`, `spaces/` and `space/{space_id}/`. `undefined` for a client
+     * built by {@link WasClient.forSpace}, which has none.
      */
-    readonly serverUrl: string;
+    readonly baseServerUrl?: string;
     /**
-     * The server base URL every Space path hangs off, without a trailing slash:
-     * the parent of {@link serverUrl} (`https://host`, or `https://host/was` on
-     * a sub-path mount). Zcap `invocationTarget`s are built beneath it.
+     * The Space URL a client built by {@link WasClient.forSpace} was opened on,
+     * in canonical form. `undefined` for a client built from a base server URL.
      */
-    readonly baseUrl: string;
+    readonly spaceUrl?: string;
     readonly zcapClient: ZcapClient;
     readonly encryption?: EncryptionProvider;
     /**
      * @param options {object}
-     * @param options.serverUrl {string}    the server's Spaces Repository URL
-     *   (`https://host/spaces/`, or `https://host/was/spaces/` on a sub-path
-     *   mount). The base URL for Space paths and zcap `invocationTarget`s is
-     *   its parent. Service discovery starts from this URL rather than from the
-     *   base, which is often a landing page with no `service` link. The value
-     *   is normalized to canonical form; `baseUrlOfSpacesUrl` in `./paths`
-     *   states what is accepted. The client is built from this URL only: a
-     *   server with no Spaces Repository (the spec leaves the endpoint
-     *   optional) has no URL this constructor accepts and is not supported.
+     * @param options.baseServerUrl {string}   the server's base server URL: an
+     *   absolute http(s) URL with no query or fragment, under which the server
+     *   serves `service`, `spaces/` and `space/{space_id}/`. A missing trailing
+     *   slash is supplied. For a server that is one fixed Space with no base,
+     *   use {@link WasClient.forSpace} instead
      * @param options.zcapClient {ZcapClient}   an ezcap client holding the signer
      * @param [options.encryption] {EncryptionProvider}   the keystore that
      *   supplies keys for collections declared encrypted (by their `encryption`
@@ -54,19 +71,60 @@ export declare class WasClient {
      *   closed rather than silently downgrading to plaintext.
      * @param [options.serviceDescription] {ServiceDescription}   a service
      *   description the caller already holds (from a cache, say). The client
-     *   selects its version from this copy instead of discovering the document
-     *   from `serverUrl`, and still refuses it with `IncompatibleServerError` if
-     *   it names no version this client speaks or advertises a Spaces Repository
-     *   other than `serverUrl`. `service({ refresh: true })` discards it and
-     *   discovers afresh.
-     * @throws {ValidationError}   when `serverUrl` is not a Spaces Repository URL
+     *   selects its version from this copy instead of discovering the document,
+     *   and still refuses it with `IncompatibleServerError` if it names no
+     *   version this client speaks, or (for a client built from a base server
+     *   URL) if it describes another server (see {@link service}).
+     *   `service({ refresh: true })` discards it and discovers afresh.
+     * @throws {ValidationError}   when `baseServerUrl` is not an absolute
+     *   http(s) URL, or carries a query or fragment
      */
-    constructor({ serverUrl, zcapClient, encryption, serviceDescription }: {
-        serverUrl: string;
+    constructor(options: {
         zcapClient: ZcapClient;
         encryption?: EncryptionProvider;
         serviceDescription?: ServiceDescription;
-    });
+    } & ({
+        baseServerUrl: string;
+    } | {
+        [fixedSpace]: string;
+    }));
+    /**
+     * Opens a client on a single fixed Space: a server that is one Space with
+     * no Space id and no base server URL (a personal site whose Collections are
+     * `https://alice.example/posts/`, `https://alice.example/images/`, ...).
+     * The service description is found by following the `service` link on an
+     * unsigned `HEAD` of the Space URL. The Space itself is
+     * `was.spaceAt(was.spaceUrl)`, and `collectionAt(url)` opens one of its
+     * Collections directly.
+     *
+     * Such a client has no base server URL, so `space(id)`, `createSpace()` and
+     * `listSpaces()` throw `NotSupportedError`. Everything Space-scoped
+     * (`spaceAt`, `collectionAt`, `fromCapability`, `grant`, `revoke`, the
+     * public reads) works as on any client. Whether the server lets a client
+     * create Collections is read from its `collection-management` feature
+     * token, as for every server.
+     *
+     * @param options {object}
+     * @param options.spaceUrl {string}   the Space's absolute URL, which may be
+     *   an origin root
+     * @param [options.zcapClient] {ZcapClient}   an ezcap client holding the
+     *   signer; one of `zcapClient` and `signer` is given
+     * @param [options.signer] {ISigner}   a signer to build the `ZcapClient`
+     *   from, as {@link fromSigner} does
+     * @param [options.encryption] {EncryptionProvider}   see the constructor
+     * @param [options.serviceDescription] {ServiceDescription}   see the
+     *   constructor; not checked against the Space URL, which names no server
+     * @returns {WasClient}
+     * @throws {ValidationError}   when `spaceUrl` is not a Space URL, or neither
+     *   or both of `zcapClient` and `signer` are given
+     */
+    static forSpace({ spaceUrl, zcapClient, signer, encryption, serviceDescription }: {
+        spaceUrl: string;
+        zcapClient?: ZcapClient;
+        signer?: ISigner;
+        encryption?: EncryptionProvider;
+        serviceDescription?: ServiceDescription;
+    }): WasClient;
     /**
      * Convenience constructor that builds the ezcap `ZcapClient` internally from
      * a signer, using the `eddsa-jcs-2022` suite for delegation proofs.
@@ -77,15 +135,15 @@ export declare class WasClient {
      * and never needs a JSON-LD document loader to serve the suite's context.
      *
      * @param options {object}
-     * @param options.serverUrl {string}
+     * @param options.baseServerUrl {string}   see the constructor
      * @param options.signer {ISigner}
      * @param [options.encryption] {EncryptionProvider}   see the constructor
      * @param [options.serviceDescription] {ServiceDescription}   see the
      *   constructor
      * @returns {WasClient}
      */
-    static fromSigner({ serverUrl, signer, encryption, serviceDescription }: {
-        serverUrl: string;
+    static fromSigner({ baseServerUrl, signer, encryption, serviceDescription }: {
+        baseServerUrl: string;
         signer: ISigner;
         encryption?: EncryptionProvider;
         serviceDescription?: ServiceDescription;
@@ -98,13 +156,15 @@ export declare class WasClient {
      */
     get controllerDid(): string;
     /**
-     * Discovers the server's service description and the WAS version this
-     * client speaks with it. Follows the `rel="service"` link on the response to
-     * an unsigned `HEAD` of `serverUrl` (the Spaces Repository URL), then reads
-     * the linked document with an unsigned `GET`. No capability is invoked. The
-     * result is memoized for the life of the client and shared by every handle;
-     * concurrent callers share one discovery, and a failure is not memoized, so
-     * the next call retries.
+     * Reads the server's service description and selects the WAS version this
+     * client speaks with it. A client built from a base server URL reads
+     * `{base}service` with an unsigned `GET` and checks that the document
+     * describes that base (its `url` and `spaces` members agree with the
+     * layout); one built by {@link forSpace} follows the `rel="service"` link on
+     * the response to an unsigned `HEAD` of the Space URL. No capability is
+     * invoked. The result is memoized for the life of the client and shared by
+     * every handle; concurrent callers share one discovery, and a failure is
+     * not memoized, so the next call retries.
      *
      * Every signed request waits on this discovery, so a caller rarely needs to
      * call it first. It is the way to read the server-wide affordances:
@@ -120,18 +180,22 @@ export declare class WasClient {
      *   caller about to rely on an affordance the server may have stopped
      *   advertising
      * @returns {Promise<ServiceInfo>}
-     * @throws {IncompatibleServerError}   when the server's responses carry no
-     *   `service` link (it predates v0.5), the document is malformed, it lists
-     *   no version this client speaks, or it advertises a Spaces Repository URL
-     *   other than `serverUrl`
+     * @throws {IncompatibleServerError}   when the probed response carries no
+     *   `service` link (the server predates v0.5), the document is malformed,
+     *   it lists no version this client speaks, or it does not describe the
+     *   server at this client's base server URL
      */
     service(options?: {
         refresh?: boolean;
     }): Promise<ServiceInfo>;
     /**
-     * Returns a lazy handle to a space by id. No I/O.
+     * Returns a lazy handle to a Space by its absolute URL, as the server
+     * named it (the `Location` of the create response, a listing item's `url`,
+     * a stored pointer, or the URL a self-locating DID resolves to). No I/O.
+     * The URL is canonicalized (see `canonicalSpaceUrl` on the `./paths`
+     * entry), and every Collection and Resource URL derives from it.
      *
-     * @param spaceId {string}
+     * @param spaceUrl {string}
      * @param options {object}
      * @param [options.capability] {IZcap}
      * @param [options.encryption] {EncryptionOverride}   the default encryption
@@ -139,13 +203,51 @@ export declare class WasClient {
      *   `EncryptionOverride`); `space.collection(id, { encryption })` overrides
      *   it per collection
      * @returns {Space}
+     * @throws {ValidationError}   when `spaceUrl` is not a Space URL
+     */
+    spaceAt(spaceUrl: string, options?: HandleOptions): Space;
+    /**
+     * Returns a lazy handle to the Space with id `spaceId` on this client's
+     * server, at `{base}space/{spaceId}/` as the spec's Server Layout places
+     * it. No I/O. The same handle as `spaceAt` opened on that URL; the Space
+     * need not exist yet (`space.configure(...)` with `ifNoneMatch` creates it
+     * by id).
+     *
+     * @param spaceId {string}
+     * @param options {object}
+     * @param [options.capability] {IZcap}
+     * @param [options.encryption] {EncryptionOverride}   see {@link spaceAt}
+     * @returns {Space}
+     * @throws {NotSupportedError}   on a client built by {@link forSpace}, which
+     *   has no base server URL
+     * @throws {ValidationError}   when `spaceId` is empty or a dot segment
      */
     space(spaceId: string, options?: HandleOptions): Space;
+    /**
+     * Returns a lazy handle to a Collection by its absolute URL: the parent
+     * container is its Space and the last segment its id, so the handle is
+     * what `spaceAt(parent).collection(id)` would produce. No I/O. The direct
+     * route for a single fixed Space, where a caller typically holds the
+     * Collection URLs (`https://alice.example/posts/`) and nothing else.
+     *
+     * @param collectionUrl {string}
+     * @param options {object}
+     * @param [options.capability] {IZcap}
+     * @param [options.encryption] {EncryptionOverride}
+     * @returns {Collection}
+     * @throws {ValidationError}   when `collectionUrl` is not a Collection URL
+     *   (no path segment beneath its origin, a query or fragment), its last
+     *   segment is a reserved Collection id, or it is not in canonical form
+     *   (so the handle's requests would address a different URL)
+     */
+    collectionAt(collectionUrl: string, options?: HandleOptions): Collection;
     /**
      * Creates a space (server-generated id unless `id` is given). `name` is
      * optional (both in the spec and on the reference server); `controller` must
      * match the wrapped signer's DID (which is the default). The request goes
-     * to the Spaces Repository URL the service description names.
+     * to the Spaces Repository, `{base}spaces/`, and the returned handle is
+     * opened on the Space URL the response's `Location` names, as the server
+     * states it.
      *
      * @param desc {object}
      * @param [desc.id] {string}
@@ -156,7 +258,9 @@ export declare class WasClient {
      *   'Space']`). The server defaults it to `['Space']` and treats it as
      *   immutable after creation
      * @returns {Promise<Space>}
-     * @throws {NotSupportedError}   when the server has no Spaces Repository
+     * @throws {NotSupportedError}   when the server has no Spaces Repository, or
+     *   the client was built by {@link forSpace}
+     * @throws {WasServerError}   when the create response carries no `Location`
      */
     createSpace(desc?: {
         id?: string;
@@ -171,7 +275,8 @@ export declare class WasClient {
      * authorized for, auxiliary spaces included. Each item carries the space's
      * `type` array, the same value as its Space Metadata object's `type`, so a
      * caller can tell an auxiliary space (one whose `type` names
-     * `AuxiliarySpace`) from a user-data one without reading each space.
+     * `AuxiliarySpace`) from a user-data one without reading each space, and
+     * its `url`, the Space URL to open a handle on with {@link spaceAt}.
      * An unauthorized caller is not an error -- the server
      * returns an empty `items` list (the spec's explicit exception to 404
      * masking), so nothing is revealed about which spaces exist.
@@ -181,7 +286,8 @@ export declare class WasClient {
      * `totalItems` counts the collected items.
      *
      * @returns {Promise<SpaceListing>}
-     * @throws {NotSupportedError}   when the server has no Spaces Repository
+     * @throws {NotSupportedError}   when the server has no Spaces Repository, or
+     *   the client was built by {@link forSpace}
      * @throws {WasServerError}   when the listing cannot be read in full
      */
     listSpaces(): Promise<SpaceListing>;
@@ -246,7 +352,15 @@ export declare class WasClient {
     /**
      * Rebuilds an access handle from a received capability, returning a handle at
      * the depth implied by the capability's `invocationTarget` (space /
-     * collection / resource), pre-bound with that capability.
+     * collection / resource), pre-bound with that capability. The Space is read
+     * off the capability's delegation chain, which starts at the Space's root
+     * capability (whose id encodes the Space URL), so a capability from any
+     * server locates its own Space with no out-of-band base. The root's target
+     * is taken to be the Space URL: a Space URL has no shape of its own, so a
+     * chain rooted elsewhere (a bare `was.grant({ target })` for a server with
+     * no Space hierarchy roots at its target) is read as if that target were
+     * the Space, and the server refuses the handle's requests. See `spaceUrlOf`
+     * on the `./paths` entry.
      *
      * A resource-scoped capability cannot read the Collection Metadata object, so
      * an encryption-capable client cannot discover whether the collection is
@@ -263,26 +377,37 @@ export declare class WasClient {
      * @param [options.encryption] {EncryptionOverride}   per-handle encryption
      *   override for the returned handle (see `EncryptionOverride`)
      * @returns {Space | Collection | Resource}
+     * @throws {ValidationError}   when the capability's chain starts at no root
+     *   capability or at one whose target cannot be a Space URL, or its
+     *   `invocationTarget` is not at or beneath that Space, addresses a
+     *   reserved sub-resource with no navigational handle, or is not in
+     *   canonical form (so the handle's requests would fall outside it)
      */
     fromCapability(zcap: IZcap, { encryption }?: {
         encryption?: EncryptionOverride;
     }): Space | Collection | Resource;
     /**
      * The general delegation primitive. Delegates a capability per `GrantOptions`
-     * and returns the signed zcap to hand off out-of-band. `target` (any URL) and
-     * `capability` (a parent capability to attenuate) make this a superset of the
-     * `space`/`collection` grant sugar.
+     * and returns the signed zcap to hand off out-of-band. `target` (any URL),
+     * `spaceUrl` (the Space to root a revocable grant in) and `capability` (a
+     * parent capability to attenuate) make this a superset of the
+     * `space`/`collection` grant sugar, which fills the first two from the
+     * handle. Without `spaceUrl` or `capability`, the grant is rooted at the
+     * target's own root capability: the shape for a server with no Space
+     * hierarchy (fixed collections, or resources alone), where there is no
+     * Space to root a chain in. Such a grant is not Space-revocable.
      *
      * @param options {GrantOptions}
      * @returns {Promise<IDelegatedZcap>}
      */
     grant(options: GrantOptions): Promise<IDelegatedZcap>;
     /**
-     * The general revocation primitive -- the inverse of {@link grant}. Derives
-     * the owning space from the capability's `invocationTarget` (which a
-     * Space-rooted capability always addresses at or beneath) and submits it to
-     * that space's revocation endpoint. Equivalent to
-     * `was.space(id).revoke(zcap)`.
+     * The general revocation primitive -- the inverse of {@link grant}. Reads
+     * the owning Space off the capability's delegation chain (a Space-rooted
+     * chain starts at the Space's root capability) and submits it to that
+     * Space's revocation endpoint. Equivalent to `was.spaceAt(url).revoke(zcap)`.
+     * The chain root's target is taken to be the Space (see `spaceUrlOf` on the
+     * `./paths` entry); the server refuses a chain not rooted exactly in it.
      *
      * Revocation is scoped to one space: there is no cross-space or global
      * revocation. See {@link Space.revoke} for who may call it, what it does and
@@ -290,12 +415,14 @@ export declare class WasClient {
      *
      * @param zcap {IDelegatedZcap}   the delegated capability to revoke
      * @returns {Promise<void>}
+     * @throws {ValidationError}   when the capability's chain starts at no root
+     *   capability, or at one whose target cannot be a Space URL
      */
     revoke(zcap: IDelegatedZcap): Promise<void>;
     /**
-     * The signed escape hatch, mirroring ezcap's generic `request()`. Resolves
-     * `path` against `baseUrl`, defaults `action` to `method`, uppercases both
-     * (as {@link grant} does, so `'put'` signs `PUT`), and signs via the wrapped
+     * The signed escape hatch, mirroring ezcap's generic `request()`. Takes an
+     * absolute `url`, defaults `action` to `method`, uppercases both (as
+     * {@link grant} does, so `'put'` signs `PUT`), and signs via the wrapped
      * client. Returns the raw `HttpResponse` and throws raw ky/ezcap
      * errors -- it does not apply the null-on-404 or typed-error conveniences.
      * Like every signed request it waits on {@link service} first, and rejects
@@ -306,4 +433,5 @@ export declare class WasClient {
      */
     request(options: RequestInput): Promise<HttpResponse>;
 }
+export {};
 //# sourceMappingURL=WasClient.d.ts.map

package/dist/WasClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WasClient.d.ts","sourceRoot":"","sources":["../src/WasClient.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AA8B/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AACpD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,cAAc,EACd,OAAO,EACP,KAAK,EACL,IAAI,EACJ,YAAY,EACZ,uBAAuB,EACvB,eAAe,EACf,WAAW,EACX,YAAY,EACb,MAAM,YAAY,CAAA;AAEnB,qBAAa,SAAS;;IACpB;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAA;IAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;gBACS,EACV,SAAS,EACT,UAAU,EACV,UAAU,EACV,kBAAkB,EACnB,EAAE;QACD,SAAS,EAAE,MAAM,CAAA;QACjB,UAAU,EAAE,UAAU,CAAA;QACtB,UAAU,CAAC,EAAE,kBAAkB,CAAA;QAC/B,kBAAkB,CAAC,EAAE,kBAAkB,CAAA;KACxC;IAgBD;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,UAAU,CAAC,EAChB,SAAS,EACT,MAAM,EACN,UAAU,EACV,kBAAkB,EACnB,EAAE;QACD,SAAS,EAAE,MAAM,CAAA;QACjB,MAAM,EAAE,OAAO,CAAA;QACf,UAAU,CAAC,EAAE,kBAAkB,CAAA;QAC/B,kBAAkB,CAAC,EAAE,kBAAkB,CAAA;KACxC,GAAG,SAAS;IASb;;;;;OAKG;IACH,IAAI,aAAa,IAAI,MAAM,CAQ1B;IAgCD;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,OAAO,CAAC,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,WAAW,CAAC;IAsDxE;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,KAAK;IAS1D;;;;;;;;;;;;;;;;OAgBG;IACG,WAAW,CACf,IAAI,GAAE;QACJ,EAAE,CAAC,EAAE,MAAM,CAAA;QACX,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,UAAU,CAAC,EAAE,MAAM,CAAA;QACnB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KACX,GACL,OAAO,CAAC,KAAK,CAAC;IAiBjB;;;;;;;;;;;;;;;;;;;OAmBG;IACG,UAAU,IAAI,OAAO,CAAC,YAAY,CAAC;IAkBzC;;;;;;;;;OASG;IACG,UAAU,CAAC,EACf,WAAW,EACZ,EAAE;QACD,WAAW,EAAE,MAAM,CAAA;KACpB,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;IAqC/B;;;;;;;;;;;;;OAaG;IACG,oBAAoB,CAAC,EACzB,aAAa,EACd,EAAE;QACD,aAAa,EAAE,MAAM,CAAA;KACtB,GAAG,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC;IAI3C;;;;;;;;;;OAUG;IACI,yBAAyB,CAAC,EAC/B,aAAa,EACd,EAAE;QACD,aAAa,EAAE,MAAM,CAAA;KACtB,GAAG,cAAc,CAAC,uBAAuB,CAAC;IAI3C;;;;;;;;;;OAUG;IACI,yBAAyB,CAAC,EAC/B,aAAa,EACd,EAAE;QACD,aAAa,EAAE,MAAM,CAAA;KACtB,GAAG,cAAc,CAAC,eAAe,CAAC;IAInC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,cAAc,CACZ,IAAI,EAAE,KAAK,EACX,EAAE,UAAU,EAAE,GAAE;QAAE,UAAU,CAAC,EAAE,kBAAkB,CAAA;KAAO,GACvD,KAAK,GAAG,UAAU,GAAG,QAAQ;IA8DhC;;;;;;;;OAQG;IACG,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC;IAI3D;;;;;;;;;;;;;OAaG;IACG,MAAM,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAQjD;;;;;;;;;;;OAWG;IACG,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;CAG5D"}
+{"version":3,"file":"WasClient.d.ts","sourceRoot":"","sources":["../src/WasClient.ts"],"names":[],"mappings":"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"}