@dork-labs/cloud-api 0.75.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dorian Collier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,192 @@
+# @dork-labs/cloud-api
+
+The public wire contract for DorkOS Cloud: Zod schemas for the `/v1` surface, the types they
+infer, the route table, and a thin `fetch` client.
+
+This package is the agreement between the DorkOS app and the hosted service. Both sides build
+against it, and neither side gets to change the wire without changing it here first.
+
+```bash
+npm install @dork-labs/cloud-api zod
+```
+
+## Two entry points
+
+```ts
+// Schemas, types and route paths. No network code, so you can validate
+// a payload without pulling in a client.
+import { EntitlementsSchema, ProblemSchema, V1_ROUTES, v1Path } from '@dork-labs/cloud-api';
+
+// The thin fetch client. No Node-only import, so a CLI, a server and a
+// browser can all use it.
+import { createCloudApiClient } from '@dork-labs/cloud-api/client';
+
+const cloud = createCloudApiClient({
+  baseUrl: process.env.MY_CLOUD_ORIGIN!, // no origin is baked into this package
+  token: () => myTokenStore.read(),
+});
+
+const entitlements = await cloud.get(V1_ROUTES.entitlements, EntitlementsSchema);
+const seat = await cloud.get(v1Path.seat(seatId), SeatSchema);
+```
+
+Every response is either the route's success schema or the `Problem` envelope. The client throws
+`CloudApiProblemError` for a refusal the service described, and `CloudApiResponseError` when the
+body is neither.
+
+## What is in the contract
+
+| Group                     | Covers                                                                                                                                                                   |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Session and account       | `GET /v1/session`, `GET /v1/account`, `POST /v1/account/export`                                                                                                          |
+| Device link               | `POST /v1/device/code`, `POST /v1/device/token` (RFC 8628)                                                                                                               |
+| Instances                 | heartbeat, revoke, list, organization re-link                                                                                                                            |
+| Managed connections       | catalog, toolkits, connections, authentication flows, authority commands, executions, the lease-based event pull and acknowledgement, usage                              |
+| Billing                   | `GET /v1/entitlements`, `/v1/balance`, `/v1/usage`, `/v1/price-list`, `/v1/nudge`, `POST /v1/checkout`, `/v1/topup`, `/v1/portal`, `GET /v1/statement`                   |
+| Inference                 | `POST /v1/inference/tokens`, `GET /v1/inference/models`, token revocation                                                                                                |
+| Seats, orgs and addresses | organizations, membership, invitations, agents and claims, seats, addresses, grants, add-ons, the seat inbox, presence                                                   |
+| Remote access             | status, open/close, wake tokens, enrolment, canonical and custom addresses, designation, instance credentials, the command stream and its acknowledgement, event batches |
+| Shared                    | the `Problem` envelope, bearer auth, cursor pagination, the `X-DorkOS-Wire: 1` header                                                                                    |
+
+### What is deliberately not in it
+
+The browser-facing `/api/auth/*` endpoints, the account and admin pages, and
+`POST /api/instances/pending` are a user interface of one application rather than a
+machine-to-machine wire. Publishing them would freeze a dependency's internals into a machine
+contract. The two device-code endpoints are the one exception: they live under `/api/auth/` today
+but are a machine wire, so they are here.
+
+The closed-address browser surface — the page an address serves while the machine is asleep,
+and the authorized reopen path on it — is excluded on the same grounds. The omission is a
+decision, not a gap.
+
+## The rules this package holds itself to
+
+### Additive within a major
+
+Within `/v1`, the only changes allowed are **new endpoints and new optional fields**. The service
+accepts the previous minor of this package, so a client one release behind keeps working.
+
+Removing a field, or making an optional field required, is a `/v2` change, served beside `/v1`
+for at least two releases. A change to a field's meaning is the same thing wearing a disguise:
+if code that was correct before is wrong after, it is not additive.
+
+### Catalog blindness
+
+**No type here enumerates the subscription catalog or the model catalog.** `planId`, `skuId`,
+`modelId`, add-on kinds, `catalogVersion` and every other catalog-shaped identifier are opaque
+strings. Not a `z.enum`, and equally not a union of literals, a `z.nativeEnum`, a hand-written
+string-literal union, a `const` array a schema is derived from, or a value named in a
+`.describe()`, a `.default()` or an `@example`.
+
+A _value_ a caller happens to be on is fine. The _set_ is not: this package publishes to public
+npm, and a `.d.ts` that enumerates the ladder publishes it permanently.
+
+The practical consequence for consumers: subscription-specific interface behaviour is driven by
+the **limit values** and the **server-supplied display string**, never by a switch on `planId`.
+There is no compile-time exhaustiveness over subscriptions here, deliberately.
+
+Enums that are fine, because they describe mechanism rather than catalog: the `Problem` codes,
+the remote `mode` and `state`, `remoteAccess`, `customAddress`, `support`, `costBasis`, the
+`supports` booleans, `groupBy`, the refusal reasons, and the RFC 8628 error set. Each one is
+listed by name with its reason in `src/__tests__/catalog-blindness.test.ts`, and a new exported
+enum fails that test until somebody writes down why it is mechanism.
+
+### Money is never a number
+
+Every amount is an **integer count of micro-units carried as a string** (`MicroAmountSchema`). A
+`z.number()` on an amount is a precision bug, not a style choice.
+
+### No origin baked in
+
+No host, origin or URL literal appears in this package. Inference endpoints are runtime values
+the mint call returns, and the client takes its `baseUrl` from the caller.
+
+No supplier is named anywhere. The two exceptions are the field names
+`endpoints.anthropicMessages` and `endpoints.openaiChat`, and they are a deliberate carve-out
+rather than an oversight: they name a **request format** a caller encodes in — both are de-facto
+public standards — not a supplier a request is routed to. Which provider actually serves a
+request is not part of this contract and is published nowhere.
+
+### Where amounts appear, and where they do not
+
+Three routes carry amounts, and it is worth being precise about which, because "no prices here"
+would be a comfortable claim and a false one:
+
+- **`GET /v1/price-list`** publishes the per-model list. That is its whole job.
+- **`GET /v1/usage`** returns, per row and in the totals, both `listPriceMicro` (the upstream
+  list price) and `dorkosPriceMicro` (what DorkOS charged). Publishing both means publishing the
+  difference, and that is the point rather than an accident: somebody paying for inference
+  through us can see exactly what the routing costs them without asking. If that ever stops
+  being the intent, the field to drop is `listPriceMicro`, and dropping it is a `/v2` change.
+- **`GET /v1/nudge`** returns one already-computed comparison — one subscription, one price, one
+  subtraction the server already did. The client renders it and computes nothing.
+
+Nothing else carries an amount. In particular, no inference route does: not a rate, not a
+multiplier, not a unit cost. And no route anywhere carries a supplier's terms.
+
+Fields typed `SecretValueSchema` are returned **once**: hold them as credential references, never
+as configuration strings, and never log them.
+
+## Conformance fixtures
+
+`fixtures/v1/**.json` is a shared corpus of example payloads, with `fixtures/v1/index.json`
+naming the exported schema that validates each one. Both sides of the wire can implement against
+the same examples; `src/__tests__/fixtures.test.ts` proves every example is valid and that the
+manifest and the directory have not drifted apart.
+
+Every example is synthetic: opaque identifiers, RFC 2606 `.invalid` hosts, and no real catalog
+value anywhere.
+
+```ts
+import entitlements from '@dork-labs/cloud-api/fixtures/v1/billing/entitlements-free.json' with { type: 'json' };
+```
+
+## Versioning, and the range to depend on
+
+This package's version **equals the DorkOS app version**, published atomically with it or not at
+all.
+
+That has a consequence worth stating plainly, because it bites silently. Lockstep bumps this
+package's **minor** on every app release, and on a `0.x` version npm reads `^0.75.0` as
+`>=0.75.0 <0.76.0`. **A caret range would lock you out of every future release.** While this
+package is pre-1.0, depend on it as:
+
+```json
+{ "dependencies": { "@dork-labs/cloud-api": ">=0.75.0 <1" } }
+```
+
+or as an exact pin your own release process bumps.
+
+## Dependencies
+
+`zod` is a **peer dependency** (`^4.6.2`), so a consumer that already has it gets one copy rather
+than two — two copies mean two answers to `instanceof`, and schemas that silently stop
+recognising each other. The range names the lowest version actually built and tested against,
+not the whole major: this package uses `z.iso.datetime` and Zod 4's `.def` internals, and a range
+wider than what CI resolves would be a compatibility claim nothing checks.
+
+There are **zero workspace dependencies**. Nothing here imports another package in this
+monorepo, and nothing in `dependencies`, `peerDependencies` or `optionalDependencies` resolves to
+one, so the package installs from public npm into a checkout that has none of this repository in
+it. `src/__tests__/packaging.test.ts` proves it from the manifest, from the imports, and from the
+workspace lockfile. The shared ESLint and TypeScript configs are `devDependencies`, which npm
+strips from the published tarball.
+
+## Development
+
+```bash
+pnpm --filter @dork-labs/cloud-api build       # ESM + .d.ts into dist/
+pnpm --filter @dork-labs/cloud-api typecheck
+pnpm --filter @dork-labs/cloud-api lint
+pnpm vitest run packages/cloud-api             # from the repo root
+```
+
+The catalog-blindness suite has one case that needs the real catalog values, which cannot live in
+this repository. Supply them to run it:
+
+```bash
+DORKOS_CATALOG_BLINDNESS_VALUES="value-a,value-b" pnpm vitest run packages/cloud-api
+```
+
+Unset, that case is reported as skipped rather than passing quietly. Set but empty, it fails.

package/dist/billing.d.ts

@@ -0,0 +1,328 @@
+import { z } from 'zod';
+/**
+ * How remote access works for the caller.
+ *
+ * Mechanism, not catalog: it says how the tunnel behaves, not what anybody
+ * bought.
+ */
+export declare const RemoteAccessCapabilitySchema: z.ZodEnum<{
+    byo: "byo";
+    on_demand: "on_demand";
+    always_available: "always_available";
+}>;
+/** Whether a custom address is unavailable, purchasable as an add-on, or already included. */
+export declare const CustomAddressCapabilitySchema: z.ZodEnum<{
+    none: "none";
+    addon: "addon";
+    included: "included";
+}>;
+/** Which support channel the caller reaches. */
+export declare const SupportCapabilitySchema: z.ZodEnum<{
+    community: "community";
+    priority: "priority";
+}>;
+/**
+ * The seat block of the entitlement.
+ *
+ * There is deliberately no field here for a count of local agents. Local agents
+ * are free and unlimited and no cloud surface counts them — the absence is part
+ * of the contract, and `src/__tests__/catalog-blindness.test.ts` keeps it.
+ */
+export declare const EntitlementSeatsSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    assigned: z.ZodNumber;
+    byKind: z.ZodObject<{
+        person: z.ZodNumber;
+        agent: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** The measurable limits of the caller`s entitlement. */
+export declare const EntitlementLimitsSchema: z.ZodObject<{
+    personSeatsIncluded: z.ZodNumber;
+    agentSeatsIncluded: z.ZodNumber;
+    includedCreditsMicro: z.ZodString;
+    cloudHours: z.ZodNumber;
+    storageGb: z.ZodNumber;
+    remoteAccess: z.ZodEnum<{
+        byo: "byo";
+        on_demand: "on_demand";
+        always_available: "always_available";
+    }>;
+    alwaysAvailableInstances: z.ZodNumber;
+    customAddress: z.ZodEnum<{
+        none: "none";
+        addon: "addon";
+        included: "included";
+    }>;
+    managedConnectionActions: z.ZodNullable<z.ZodNumber>;
+    support: z.ZodEnum<{
+        community: "community";
+        priority: "priority";
+    }>;
+    emailAddressPerSeat: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * `GET /v1/entitlements` — what the caller is allowed to do.
+ *
+ * A caller with no subscription gets 200 and the free entitlement, never a 404.
+ * Somebody who has never touched billing is a valid caller and the normal case.
+ *
+ * `planId` is opaque. There is no compile-time exhaustiveness over plans here,
+ * deliberately: a client renders `planDisplayName` and branches on the limit
+ * values, never on the identifier.
+ */
+export declare const EntitlementsSchema: z.ZodObject<{
+    planId: z.ZodString;
+    planDisplayName: z.ZodString;
+    periodStart: z.ZodISODateTime;
+    periodEnd: z.ZodISODateTime;
+    limits: z.ZodObject<{
+        personSeatsIncluded: z.ZodNumber;
+        agentSeatsIncluded: z.ZodNumber;
+        includedCreditsMicro: z.ZodString;
+        cloudHours: z.ZodNumber;
+        storageGb: z.ZodNumber;
+        remoteAccess: z.ZodEnum<{
+            byo: "byo";
+            on_demand: "on_demand";
+            always_available: "always_available";
+        }>;
+        alwaysAvailableInstances: z.ZodNumber;
+        customAddress: z.ZodEnum<{
+            none: "none";
+            addon: "addon";
+            included: "included";
+        }>;
+        managedConnectionActions: z.ZodNullable<z.ZodNumber>;
+        support: z.ZodEnum<{
+            community: "community";
+            priority: "priority";
+        }>;
+        emailAddressPerSeat: z.ZodBoolean;
+    }, z.core.$strip>;
+    used: z.ZodObject<{
+        personSeats: z.ZodNumber;
+        agentSeats: z.ZodNumber;
+    }, z.core.$strip>;
+    seats: z.ZodObject<{
+        total: z.ZodNumber;
+        assigned: z.ZodNumber;
+        byKind: z.ZodObject<{
+            person: z.ZodNumber;
+            agent: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    canCreateSeat: z.ZodBoolean;
+    canInviteMember: z.ZodBoolean;
+    staleAt: z.ZodISODateTime;
+}, z.core.$strip>;
+/** What the caller is allowed to do. */
+export type Entitlements = z.infer<typeof EntitlementsSchema>;
+/**
+ * `GET /v1/balance` — the caller`s credit position.
+ *
+ * `owedMicro` is not optional and not cosmetic: it is debt carried from a turn
+ * that overran its reservation. When it is non-zero an interface must show it,
+ * and a purchase that repays it renders the repayment as its own line before
+ * the new balance rather than as a quietly smaller number.
+ */
+export declare const BalanceSchema: z.ZodObject<{
+    allowance: z.ZodObject<{
+        grantedMicro: z.ZodString;
+        remainingMicro: z.ZodString;
+        resetsAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    purchased: z.ZodObject<{
+        remainingMicro: z.ZodString;
+    }, z.core.$strip>;
+    heldMicro: z.ZodString;
+    owedMicro: z.ZodString;
+    autoReload: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        ceilingMicro: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** The caller`s credit position. */
+export type Balance = z.infer<typeof BalanceSchema>;
+/**
+ * Where a usage line`s price came from.
+ *
+ * `published_price` is the published DorkOS price. It is a separate value from
+ * `managed`, which means rates an organization configured for itself and
+ * explicitly not a public price — rendering published prices under `managed`
+ * would tell a person their rate is non-public, which inverts the meaning.
+ */
+export declare const CostBasisSchema: z.ZodEnum<{
+    byo_key: "byo_key";
+    managed: "managed";
+    published_price: "published_price";
+}>;
+/** Where a usage line`s price came from. */
+export type CostBasis = z.infer<typeof CostBasisSchema>;
+/**
+ * How a credit or subscription position reads at a glance.
+ *
+ * Widened past subscription language on purpose: `exhausted` describes a credit
+ * balance that has run out, which a subscription vocabulary has no word for.
+ */
+export declare const UsageStateSchema: z.ZodEnum<{
+    inactive: "inactive";
+    active: "active";
+    grace: "grace";
+    exhausted: "exhausted";
+    unknown: "unknown";
+}>;
+/** How to group a usage query. */
+export declare const UsageGroupBySchema: z.ZodEnum<{
+    seat: "seat";
+    model: "model";
+    day: "day";
+}>;
+/** `GET /v1/usage` query parameters. */
+export declare const UsageQuerySchema: z.ZodObject<{
+    from: z.ZodISODateTime;
+    to: z.ZodISODateTime;
+    groupBy: z.ZodEnum<{
+        seat: "seat";
+        model: "model";
+        day: "day";
+    }>;
+}, z.core.$strip>;
+/**
+ * One row of the caller`s usage.
+ *
+ * Carries BOTH the upstream list price and what DorkOS charged, which means it
+ * carries the difference between them. That is deliberate rather than
+ * accidental: somebody paying for inference through DorkOS can see what the
+ * routing costs them without having to ask. Dropping `listPriceMicro` is the
+ * change that would undo it, and dropping a field is a `/v2` change.
+ *
+ * There is deliberately no supplier field and no price-list version identifier
+ * here. Neither is published, and neither may be inferred client-side.
+ */
+export declare const UsageRowSchema: z.ZodObject<{
+    key: z.ZodString;
+    displayName: z.ZodString;
+    units: z.ZodNumber;
+    unit: z.ZodString;
+    listPriceMicro: z.ZodString;
+    dorkosPriceMicro: z.ZodString;
+    costBasis: z.ZodEnum<{
+        byo_key: "byo_key";
+        managed: "managed";
+        published_price: "published_price";
+    }>;
+}, z.core.$strip>;
+/** `GET /v1/usage` — the caller`s own usage for a window. */
+export declare const UsageResponseSchema: z.ZodObject<{
+    from: z.ZodISODateTime;
+    to: z.ZodISODateTime;
+    groupBy: z.ZodEnum<{
+        seat: "seat";
+        model: "model";
+        day: "day";
+    }>;
+    state: z.ZodEnum<{
+        inactive: "inactive";
+        active: "active";
+        grace: "grace";
+        exhausted: "exhausted";
+        unknown: "unknown";
+    }>;
+    rows: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        displayName: z.ZodString;
+        units: z.ZodNumber;
+        unit: z.ZodString;
+        listPriceMicro: z.ZodString;
+        dorkosPriceMicro: z.ZodString;
+        costBasis: z.ZodEnum<{
+            byo_key: "byo_key";
+            managed: "managed";
+            published_price: "published_price";
+        }>;
+    }, z.core.$strip>>;
+    totals: z.ZodObject<{
+        listPriceMicro: z.ZodString;
+        dorkosPriceMicro: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** The caller`s own usage for a window. */
+export type UsageResponse = z.infer<typeof UsageResponseSchema>;
+/** One entry of the published price list. */
+export declare const PriceListEntrySchema: z.ZodObject<{
+    modelId: z.ZodString;
+    displayName: z.ZodString;
+    unit: z.ZodString;
+    inputMicro: z.ZodString;
+    outputMicro: z.ZodString;
+}, z.core.$strip>;
+/**
+ * `GET /v1/price-list` — the published per-model price list.
+ *
+ * Published by design. It carries nothing about how the list is arrived at and
+ * no commercial terms. It is not the only route carrying an amount — `/v1/usage`
+ * and `/v1/nudge` both do, for the caller's own figures — but it is the only one
+ * that publishes the list itself.
+ */
+export declare const PriceListResponseSchema: z.ZodObject<{
+    version: z.ZodString;
+    effectiveFrom: z.ZodISODateTime;
+    entries: z.ZodArray<z.ZodObject<{
+        modelId: z.ZodString;
+        displayName: z.ZodString;
+        unit: z.ZodString;
+        inputMicro: z.ZodString;
+        outputMicro: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * `GET /v1/nudge` — one already-computed comparison, delivered reduced.
+ *
+ * The server does the subtraction; the client renders what it is given and
+ * computes nothing. Exactly one subscription and one price ever appear. The
+ * route sits behind a server flag and answers 404 until it is switched on, so a
+ * client treats 404 here as "no nudge", not as an error.
+ */
+export declare const NudgeSchema: z.ZodObject<{
+    trailing30Micro: z.ZodString;
+    suggestedPlanId: z.ZodString;
+    suggestedPlanDisplayName: z.ZodString;
+    suggestedPlanPriceMicro: z.ZodString;
+    savingMicro: z.ZodString;
+    computedAt: z.ZodISODateTime;
+    dismissible: z.ZodLiteral<true>;
+}, z.core.$strip>;
+/** One already-computed comparison. */
+export type Nudge = z.infer<typeof NudgeSchema>;
+/**
+ * A request for a hosted page.
+ *
+ * `skuId` is an identifier the client received from the server. A client never
+ * constructs one and never enumerates the set. The amount and its rendering
+ * belong to the hosted page, not to this contract.
+ */
+export declare const HostedPageRequestSchema: z.ZodObject<{
+    skuId: z.ZodOptional<z.ZodString>;
+    returnUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * The hosted page to open.
+ *
+ * `POST /v1/checkout`, `POST /v1/topup` and `POST /v1/portal` all answer with
+ * this. No origin is baked into this package: the URL is a runtime value.
+ */
+export declare const HostedPageResponseSchema: z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>;
+/** `GET /v1/statement` query parameters. */
+export declare const StatementQuerySchema: z.ZodObject<{
+    period: z.ZodString;
+}, z.core.$strip>;
+/** `GET /v1/statement` — a download link for the caller`s itemised statement. */
+export declare const StatementResponseSchema: z.ZodObject<{
+    period: z.ZodString;
+    downloadUrl: z.ZodString;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+//# sourceMappingURL=billing.d.ts.map

package/dist/billing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"billing.d.ts","sourceRoot":"","sources":["../src/billing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B;;;;EAItC,CAAC;AAEJ,8FAA8F;AAC9F,eAAO,MAAM,6BAA6B;;;;EAIvC,CAAC;AAEJ,gDAAgD;AAChD,eAAO,MAAM,uBAAuB;;;EAEoB,CAAC;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;iBASmC,CAAC;AAEvE,yDAAyD;AACzD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;iBAuBjC,CAAC;AAEJ;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoB5B,CAAC;AAEJ,wCAAwC;AACxC,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;iBAmBvB,CAAC;AAEJ,oCAAoC;AACpC,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;;EAIzB,CAAC;AAEJ,4CAA4C;AAC5C,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;EAE0C,CAAC;AAExE,kCAAkC;AAClC,eAAO,MAAM,kBAAkB;;;;EAEW,CAAC;AAE3C,wCAAwC;AACxC,eAAO,MAAM,gBAAgB;;;;;;;;iBAM4B,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;iBAmBxB,CAAC;AAEJ,6DAA6D;AAC7D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYqC,CAAC;AAEtE,2CAA2C;AAC3C,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,6CAA6C;AAC7C,eAAO,MAAM,oBAAoB;;;;;;iBAUoB,CAAC;AAEtD;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;iBAQjC,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW;;;;;;;;iBAU2E,CAAC;AAEpG,uCAAuC;AACvC,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;;;iBAW0C,CAAC;AAE/E;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;iBAEyD,CAAC;AAE/F,4CAA4C;AAC5C,eAAO,MAAM,oBAAoB;;iBAI4B,CAAC;AAE9D,iFAAiF;AACjF,eAAO,MAAM,uBAAuB;;;;iBAMqD,CAAC"}