@misofm/sdk 0.1.0

package/dist/contracts/miso_pressing/pressing.d.ts

@@ -0,0 +1,365 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * A release's record production — its _Pressing_.
+ *
+ * A release has exactly one pressing, and the pressing is one uncapped run of
+ * records: every copy ever made draws its number from this single counter,
+ * forever. There are no editions, no supply caps, and no sold-out state — scarcity
+ * on Miso is what a record _accrues_ (playtime above all), not how few of it were
+ * printed. The pressing owns two things and only two things: the **run** the
+ * records number against, and the **switch** that stops it.
+ *
+ * ```text
+ * Release
+ *  └─ Pressing              the run, and when it sells at all       PressingKey()
+ *      ├─ PressingAdminCap  authority over price and state         PressingAdminCapKey()
+ *      ├─ Listing<SUI>      what it costs in one currency          ListingKey<SUI>()
+ *      └─ Listing<USDC>
+ * ```
+ *
+ * # Everything is address math
+ *
+ * A pressing's UID is derived off its release's UID at a singleton key, its admin
+ * cap's and each listing's off the pressing's, and records off the pressing's at
+ * their number. So every object in the tree is reachable from the release id
+ * alone, by pure computation — no registry, no pointer that has to be maintained,
+ * and no stored set of listings: a listing either exists at its derived address or
+ * it does not (`listing::has_listing`), and `ListingOpenedEvent<Currency>`
+ * enumerates them for an indexer. It also makes the number sequence gap-free for
+ * free, and every record verifiable against its pressing from chain state alone
+ * (`verify_record`).
+ *
+ * # Starting and stopping is state, never teardown
+ *
+ * Nothing here is ever destroyed, sealed, or wound down — deleting a pressing
+ * would strand its whole derived subtree, so there is no destructor at all. The
+ * run's lifecycle is `Scheduled → Active → Paused → Active`: it opens itself at
+ * its drop moment (no artist transaction, and nobody can buy early), and after
+ * that the artist stops and starts it at will. The first transition is real, not
+ * computed — the first sale past the start rewrites `Scheduled` to `Active` inside
+ * `mint_next`, which is why `Scheduled` only ever describes a run still waiting.
+ * Below it, each listing's `Enabled | Disabled` governs one currency. A run that
+ * is paused or not yet open sells in no currency, whatever the listings say.
+ *
+ * There is no end state and no expiry: an uncapped, permanent run has nothing to
+ * count down to, and a time-limited sale is scarcity theater this design rejects.
+ * An artist ending a campaign pauses it.
+ *
+ * # Authority
+ *
+ * Opening a pressing needs the release's `ReleaseAdminCap`, enforced by the
+ * protocol's `release::uid_mut`, and hands back a `PressingAdminCap`. Everything
+ * after that — pricing, pausing, opening listings — authorizes against the
+ * pressing cap alone.
+ *
+ * The split is deliberate and it is about money, not tidiness. `ReleaseAdminCap`
+ * yields `release::uid_mut`, and `balance::withdraw_funds_from_object` is gated on
+ * `&mut UID` alone — so the release cap can withdraw the sales revenue that `buy`
+ * forwards to the release's address. Under one cap, "may reprice a listing" and
+ * "may take the money" would be the same grant. The pressing cap is the routine
+ * one, safe to delegate to whoever runs the shop; the release cap stays with the
+ * rightsholder.
+ */
+import { MoveTuple, MoveStruct, MoveEnum, type RawTransactionArgument } from '../utils/index.js';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+export declare const PressingKey: MoveTuple<readonly [import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">], "@local-pkg/miso_pressing::pressing::PressingKey">;
+export declare const PressingAdminCapKey: MoveTuple<readonly [import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">], "@local-pkg/miso_pressing::pressing::PressingAdminCapKey">;
+export declare const MintWitness: MoveStruct<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@local-pkg/miso_pressing::pressing::MintWitness">;
+/**
+ * Whether the run sells, over every currency at once. The lifecycle runs
+ * `Scheduled → Active → Paused → Active`: a pressing opens itself at its drop
+ * moment, then the artist stops and starts it at will.
+ */
+export declare const PressingState: MoveEnum<{
+    /**
+      * Opens the moment the clock passes `start_timestamp_ms` (Unix ms), with no
+      * further action from anyone. A start already in the past sells now.
+      *
+      * This is a _transitional_ state: the first sale past the start rewrites it to
+      * `Active` (in `mint_next`, before any sales logic), so a run reads `Scheduled`
+      * only while it is still waiting. Between the start and that first sale the run
+      * already sells — `is_selling` answers against the clock — so nobody has to go
+      * first for the drop to be open.
+      *
+      * Consequence worth knowing: once the transition fires the start time is gone from
+      * the object. `PressingOpenedEvent` and `PressingStateChangedEvent` carry it, so
+      * "when was this run scheduled for" is an event-log question, not an object read.
+      */
+    Scheduled: MoveStruct<{
+        start_timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "PressingState.Scheduled">;
+    /** Selling, subject to each listing's own state. */
+    Active: null;
+    /** Selling in no currency, whatever the listings say. */
+    Paused: null;
+}, "@local-pkg/miso_pressing::pressing::PressingState">;
+export declare const Pressing: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** The release these records are copies of. */
+    release_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** Whether the run sells at all, in any currency. */
+    state: MoveEnum<{
+        /**
+          * Opens the moment the clock passes `start_timestamp_ms` (Unix ms), with no
+          * further action from anyone. A start already in the past sells now.
+          *
+          * This is a _transitional_ state: the first sale past the start rewrites it to
+          * `Active` (in `mint_next`, before any sales logic), so a run reads `Scheduled`
+          * only while it is still waiting. Between the start and that first sale the run
+          * already sells — `is_selling` answers against the clock — so nobody has to go
+          * first for the drop to be open.
+          *
+          * Consequence worth knowing: once the transition fires the start time is gone from
+          * the object. `PressingOpenedEvent` and `PressingStateChangedEvent` carry it, so
+          * "when was this run scheduled for" is an event-log question, not an object read.
+          */
+        Scheduled: MoveStruct<{
+            start_timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        }, "PressingState.Scheduled">;
+        /** Selling, subject to each listing's own state. */
+        Active: null;
+        /** Selling in no currency, whatever the listings say. */
+        Paused: null;
+    }, "@local-pkg/miso_pressing::pressing::PressingState">;
+    /**
+     * Records pressed so far; also the most recent number. Read on every mint — this
+     * is the sequence itself, not a statistic.
+     */
+    supply: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/miso_pressing::pressing::Pressing">;
+export declare const PressingAdminCap: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** The pressing this cap controls. Every mutator asserts against it. */
+    pressing_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@local-pkg/miso_pressing::pressing::PressingAdminCap">;
+export declare const PressingOpenedEvent: MoveStruct<{
+    pressing_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    release_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    state: MoveEnum<{
+        /**
+          * Opens the moment the clock passes `start_timestamp_ms` (Unix ms), with no
+          * further action from anyone. A start already in the past sells now.
+          *
+          * This is a _transitional_ state: the first sale past the start rewrites it to
+          * `Active` (in `mint_next`, before any sales logic), so a run reads `Scheduled`
+          * only while it is still waiting. Between the start and that first sale the run
+          * already sells — `is_selling` answers against the clock — so nobody has to go
+          * first for the drop to be open.
+          *
+          * Consequence worth knowing: once the transition fires the start time is gone from
+          * the object. `PressingOpenedEvent` and `PressingStateChangedEvent` carry it, so
+          * "when was this run scheduled for" is an event-log question, not an object read.
+          */
+        Scheduled: MoveStruct<{
+            start_timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        }, "PressingState.Scheduled">;
+        /** Selling, subject to each listing's own state. */
+        Active: null;
+        /** Selling in no currency, whatever the listings say. */
+        Paused: null;
+    }, "@local-pkg/miso_pressing::pressing::PressingState">;
+}, "@local-pkg/miso_pressing::pressing::PressingOpenedEvent">;
+export declare const PressingStateChangedEvent: MoveStruct<{
+    pressing_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    state: MoveEnum<{
+        /**
+          * Opens the moment the clock passes `start_timestamp_ms` (Unix ms), with no
+          * further action from anyone. A start already in the past sells now.
+          *
+          * This is a _transitional_ state: the first sale past the start rewrites it to
+          * `Active` (in `mint_next`, before any sales logic), so a run reads `Scheduled`
+          * only while it is still waiting. Between the start and that first sale the run
+          * already sells — `is_selling` answers against the clock — so nobody has to go
+          * first for the drop to be open.
+          *
+          * Consequence worth knowing: once the transition fires the start time is gone from
+          * the object. `PressingOpenedEvent` and `PressingStateChangedEvent` carry it, so
+          * "when was this run scheduled for" is an event-log question, not an object read.
+          */
+        Scheduled: MoveStruct<{
+            start_timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        }, "PressingState.Scheduled">;
+        /** Selling, subject to each listing's own state. */
+        Active: null;
+        /** Selling in no currency, whatever the listings say. */
+        Paused: null;
+    }, "@local-pkg/miso_pressing::pressing::PressingState">;
+}, "@local-pkg/miso_pressing::pressing::PressingStateChangedEvent">;
+export interface NewScheduledStateArguments {
+    startTimestampMs: RawTransactionArgument<number | bigint>;
+}
+export interface NewScheduledStateOptions {
+    package?: string;
+    arguments: NewScheduledStateArguments | [
+        startTimestampMs: RawTransactionArgument<number | bigint>
+    ];
+}
+/** The scheduled state: the run opens itself at `start_timestamp_ms` (Unix ms). */
+export declare function newScheduledState(options: NewScheduledStateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewActiveStateOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** The active state: the run sells, subject to each listing's own state. */
+export declare function newActiveState(options?: NewActiveStateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewPausedStateOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** The paused state: the run sells in no currency. */
+export declare function newPausedState(options?: NewPausedStateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewArguments {
+    release: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    state: TransactionArgument;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        release: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        state: TransactionArgument
+    ];
+}
+/**
+ * Open a release's pressing in `state` — `Scheduled` for a drop moment, `Active`
+ * to sell immediately, `Paused` to set it up quietly. Returns it unshared, so the
+ * same transaction can list it (`listing::new`) before `share` puts it on chain,
+ * plus the cap that governs it from here on. Neither value has `drop`, so neither
+ * can be lost by forgetting.
+ *
+ * Claim-once on `PressingKey()` means a release's pressing can only ever be opened
+ * here, exactly once; calling this twice for the same release aborts.
+ */
+export declare function _new(options: NewOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ShareArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ShareOptions {
+    package?: string;
+    arguments: ShareArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Put the pressing on chain. `new` hands back an unshared `Pressing` so the same
+ * transaction can list it first; this is the last call in that sequence.
+ */
+export declare function share(options: ShareOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetStateArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    state: TransactionArgument;
+}
+export interface SetStateOptions {
+    package?: string;
+    arguments: SetStateArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        state: TransactionArgument
+    ];
+}
+/**
+ * Move the run between its three modes — schedule it, open it, stop it. Takes
+ * effect across every currency at once, regardless of any listing's own state.
+ */
+export declare function setState(options: SetStateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DeriveIdArguments {
+    releaseId: RawTransactionArgument<string>;
+}
+export interface DeriveIdOptions {
+    package?: string;
+    arguments: DeriveIdArguments | [
+        releaseId: RawTransactionArgument<string>
+    ];
+}
+/**
+ * The address `release_id`'s pressing occupies — pure address math, computable
+ * before the pressing has been opened.
+ */
+export declare function deriveId(options: DeriveIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IdOptions {
+    package?: string;
+    arguments: IdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+export declare function id(options: IdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ReleaseIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ReleaseIdOptions {
+    package?: string;
+    arguments: ReleaseIdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+export declare function releaseId(options: ReleaseIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SupplyArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface SupplyOptions {
+    package?: string;
+    arguments: SupplyArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Records pressed so far; also the most recent number. */
+export declare function supply(options: SupplyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsSellingArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IsSellingOptions {
+    package?: string;
+    arguments: IsSellingArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Whether the run sells _right now_ — the question `buy` actually asks.
+ * `Scheduled` answers it against the clock, so a run past its start that has not
+ * yet had a sale to settle it reads as selling, which it is.
+ */
+export declare function isSelling(options: IsSellingOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PressingAdminCapPressingIdArguments {
+    cap: RawTransactionArgument<string>;
+}
+export interface PressingAdminCapPressingIdOptions {
+    package?: string;
+    arguments: PressingAdminCapPressingIdArguments | [
+        cap: RawTransactionArgument<string>
+    ];
+}
+/**
+ * The pressing this cap controls. Public so a custody layer holding the cap can
+ * tell what it governs without the `Pressing` object.
+ */
+export declare function pressingAdminCapPressingId(options: PressingAdminCapPressingIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifyRecordArguments {
+    record: RawTransactionArgument<string>;
+}
+export interface VerifyRecordOptions {
+    package?: string;
+    arguments: VerifyRecordArguments | [
+        record: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Whether `record` is genuinely the copy its certificate claims it is, checked
+ * from chain state alone and without needing the `Pressing` object.
+ *
+ * The record must sit at exactly the address its certificate number derives to off
+ * its release's pressing. The certificate is the readable form of what the address
+ * already proves.
+ */
+export declare function verifyRecord(options: VerifyRecordOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+//# sourceMappingURL=pressing.d.ts.map

package/dist/contracts/miso_pressing/pressing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pressing.d.ts","sourceRoot":"","sources":["../../../src/contracts/miso_pressing/pressing.ts"],"names":[],"mappings":"AAAA;;gEAEgE;AAGhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAA0B,KAAK,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEzH,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEtF,eAAO,MAAM,WAAW,sIAA+E,CAAC;AACxG,eAAO,MAAM,mBAAmB,8IAAuF,CAAC;AACxH,eAAO,MAAM,WAAW;;qDAEhB,CAAC;AACT;;;;GAIG;AACH,eAAO,MAAM,aAAa;IAClB;;;;;;;;;;;;;QAaI;;;;IAIJ,oDAAoD;;IAEpD,yDAAyD;;uDAEzD,CAAC;AACT,eAAO,MAAM,QAAQ;;IAEb,+CAA+C;;IAE/C,qDAAqD;;QA1BrD;;;;;;;;;;;;;YAaI;;;;QAIJ,oDAAoD;;QAEpD,yDAAyD;;;IASzD;;;OAGG;;kDAEH,CAAC;AACT,eAAO,MAAM,gBAAgB;;IAErB,wEAAwE;;0DAExE,CAAC;AACT,eAAO,MAAM,mBAAmB;;;;QAvCxB;;;;;;;;;;;;;YAaI;;;;QAIJ,oDAAoD;;QAEpD,yDAAyD;;;6DAwBzD,CAAC;AACT,eAAO,MAAM,yBAAyB;;;QA5C9B;;;;;;;;;;;;;YAaI;;;;QAIJ,oDAAoD;;QAEpD,yDAAyD;;;mEA4BzD,CAAC;AACT,MAAM,WAAW,0BAA0B;IACvC,gBAAgB,EAAE,sBAAsB,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;CAC7D;AACD,MAAM,WAAW,wBAAwB;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,0BAA0B,GAAG;QACpC,gBAAgB,EAAE,sBAAsB,CAAC,MAAM,GAAG,MAAM,CAAC;KAC5D,CAAC;CACL;AACD,mFAAmF;AACnF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,IAMvD,IAAI,WAAW,0DAM1B;AACD,MAAM,WAAW,qBAAqB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE;KACX,CAAC;CACL;AACD,4EAA4E;AAC5E,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,IAEtD,IAAI,WAAW,0DAK1B;AACD,MAAM,WAAW,qBAAqB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE;KACX,CAAC;CACL;AACD,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,IAEtD,IAAI,WAAW,0DAK1B;AACD,MAAM,WAAW,YAAY;IACzB,OAAO,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;IACxC,GAAG,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;IACpC,KAAK,EAAE,mBAAmB,CAAC;CAC9B;AACD,MAAM,WAAW,UAAU;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,YAAY,GAAG;QACtB,OAAO,EAAE,sBAAsB,CAAC,MAAM,CAAC;QACvC,GAAG,EAAE,sBAAsB,CAAC,MAAM,CAAC;QACnC,KAAK,EAAE,mBAAmB;KAC7B,CAAC;CACL;AACD;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,UAAU,IAQ5B,IAAI,WAAW,0DAM1B;AACD,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;CACxC;AACD,MAAM,WAAW,YAAY;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,cAAc,GAAG;QACxB,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC;KACvC,CAAC;CACL;AACD;;;GAGG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,YAAY,IAM/B,IAAI,WAAW,0DAM1B;AACD,MAAM,WAAW,iBAAiB;IAC9B,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;IACrC,GAAG,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;IACpC,KAAK,EAAE,mBAAmB,CAAC;CAC9B;AACD,MAAM,WAAW,eAAe;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,iBAAiB,GAAG;QAC3B,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC;QACpC,GAAG,EAAE,sBAAsB,CAAC,MAAM,CAAC;QACnC,KAAK,EAAE,mBAAmB;KAC7B,CAAC;CACL;AACD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,eAAe,IAQrC,IAAI,WAAW,0DAM1B;AACD,MAAM,WAAW,iBAAiB;IAC9B,SAAS,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;CAC7C;AACD,MAAM,WAAW,eAAe;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,iBAAiB,GAAG;QAC3B,SAAS,EAAE,sBAAsB,CAAC,MAAM,CAAC;KAC5C,CAAC;CACL;AACD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,eAAe,IAMrC,IAAI,WAAW,0DAM1B;AACD,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;CACxC;AACD,MAAM,WAAW,SAAS;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,WAAW,GAAG;QACrB,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC;KACvC,CAAC;CACL;AACD,wBAAgB,EAAE,CAAC,OAAO,EAAE,SAAS,IAMzB,IAAI,WAAW,0DAM1B;AACD,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;CACxC;AACD,MAAM,WAAW,gBAAgB;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,kBAAkB,GAAG;QAC5B,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC;KACvC,CAAC;CACL;AACD,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,IAMvC,IAAI,WAAW,0DAM1B;AACD,MAAM,WAAW,eAAe;IAC5B,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;CACxC;AACD,MAAM,WAAW,aAAa;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,eAAe,GAAG;QACzB,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC;KACvC,CAAC;CACL;AACD,2DAA2D;AAC3D,wBAAgB,MAAM,CAAC,OAAO,EAAE,aAAa,IAMjC,IAAI,WAAW,0DAM1B;AACD,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;CACxC;AACD,MAAM,WAAW,gBAAgB;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,kBAAkB,GAAG;QAC5B,IAAI,EAAE,sBAAsB,CAAC,MAAM,CAAC;KACvC,CAAC;CACL;AACD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,IAOvC,IAAI,WAAW,0DAM1B;AACD,MAAM,WAAW,mCAAmC;IAChD,GAAG,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;CACvC;AACD,MAAM,WAAW,iCAAiC;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,mCAAmC,GAAG;QAC7C,GAAG,EAAE,sBAAsB,CAAC,MAAM,CAAC;KACtC,CAAC;CACL;AACD;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,iCAAiC,IAMzE,IAAI,WAAW,0DAM1B;AACD,MAAM,WAAW,qBAAqB;IAClC,MAAM,EAAE,sBAAsB,CAAC,MAAM,CAAC,CAAC;CAC1C;AACD,MAAM,WAAW,mBAAmB;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,qBAAqB,GAAG;QAC/B,MAAM,EAAE,sBAAsB,CAAC,MAAM,CAAC;KACzC,CAAC;CACL;AACD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,IAM7C,IAAI,WAAW,0DAM1B"}