@crowdedkingdoms/crowdyjs 8.2.0 → 8.3.0

package/dist/kit/blueprints/locks.js

@@ -0,0 +1,155 @@
+import { andPolicies, kitPolicyJson, toSnakeCase, } from './core.js';
+/** Compute the type/function names a lock blueprint (and its runtime helper) uses. */
+export function lockNames(objectTypeName = 'Lockable', keyTypeName) {
+    const snake = toSnakeCase(objectTypeName);
+    return {
+        objectType: objectTypeName,
+        keyType: keyTypeName ?? `${objectTypeName}Key`,
+        openFn: `open_${snake}`,
+        closeFn: `close_${snake}`,
+    };
+}
+function lockAuthorityRule(authority) {
+    switch (authority.kind) {
+        case 'owner':
+            return { type: 'owner_of_self' };
+        case 'key':
+            // Container ownership is not readable from expressions, so the key
+            // mirrors its owner into an `owner_user_id` property; the condition
+            // verifies both the match and the ownership server-side.
+            return {
+                type: 'condition',
+                expression: 'ref($key_id).key_id == self.required_key_id && ref($key_id).owner_user_id == $caller_user_id',
+            };
+        case 'gridPermission':
+            return {
+                type: 'grid_permission',
+                key: authority.key,
+                ...(authority.gridId !== undefined ? { gridId: authority.gridId } : {}),
+            };
+        case 'chunkPermission':
+            // Resolved per-invocation against the grid covering the object's chunk.
+            return {
+                type: 'condition',
+                expression: `has_chunk_permission($caller_user_id, "${authority.key}", self.cx, self.cy, self.cz, "${authority.mode ?? 'first'}")`,
+            };
+        case 'groupPermission':
+            return {
+                type: 'group_permission',
+                groupId: authority.groupId,
+                ...(authority.permission !== undefined
+                    ? { permission: authority.permission }
+                    : {}),
+            };
+        case 'custom':
+            return authority.rule;
+    }
+}
+/**
+ * Blueprint for a **lockable game object** (door, chest, gate, switch) whose
+ * `open`/`close` functions are gated by a configurable authority source:
+ * ownership, a key item the caller must hold, a runtime grid permission, a
+ * team/group permission, or any custom policy rule. Multiple authorities are
+ * OR'd, so "the owner, or anyone with the right key" is one blueprint.
+ *
+ * Runtime counterpart: `client.kit(appId).objects`.
+ */
+export function lockBlueprint(options) {
+    const authorities = Array.isArray(options.authority)
+        ? options.authority
+        : [options.authority];
+    if (authorities.length === 0) {
+        throw new Error('lockBlueprint requires at least one authority source');
+    }
+    const names = lockNames(options.objectTypeName, options.keyTypeName);
+    const usesKey = authorities.some((a) => a.kind === 'key');
+    const usesChunk = authorities.some((a) => a.kind === 'chunkPermission');
+    const rules = authorities.map(lockAuthorityRule);
+    const policy = rules.length === 1 ? rules[0] : { type: 'or', rules };
+    const policyJson = kitPolicyJson(andPolicies(policy, options.policyExtra));
+    const parameters = usesKey
+        ? [{ name: 'key_id', valueType: 'container_ref', required: true }]
+        : [];
+    const containerTypes = [
+        {
+            typeName: names.objectType,
+            displayName: names.objectType,
+            instantiableBy: 'admin',
+            description: 'A lockable world object operated through gated functions.',
+        },
+    ];
+    const propertyDefinitions = [
+        {
+            containerTypeName: names.objectType,
+            key: 'is_open',
+            valueType: 'bool',
+            defaultValueJson: 'false',
+        },
+    ];
+    if (usesChunk) {
+        // The chunk the object stands in, read by has_chunk_permission().
+        for (const axis of ['cx', 'cy', 'cz']) {
+            propertyDefinitions.push({
+                containerTypeName: names.objectType,
+                key: axis,
+                valueType: 'int',
+                defaultValueJson: '0',
+            });
+        }
+    }
+    if (usesKey) {
+        propertyDefinitions.push({
+            containerTypeName: names.objectType,
+            key: 'required_key_id',
+            valueType: 'string',
+        });
+        containerTypes.push({
+            typeName: names.keyType,
+            displayName: names.keyType,
+            instantiableBy: 'admin',
+            description: 'A key item granting access to matching lockable objects.',
+        });
+        propertyDefinitions.push({ containerTypeName: names.keyType, key: 'key_id', valueType: 'string' }, {
+            containerTypeName: names.keyType,
+            key: 'owner_user_id',
+            valueType: 'int',
+        });
+    }
+    const openMutation = {
+        target: 'self',
+        property: 'is_open',
+        expression: 'true',
+    };
+    const closeMutation = {
+        target: 'self',
+        property: 'is_open',
+        expression: 'false',
+    };
+    return {
+        name: names.objectType,
+        containerTypes,
+        propertyDefinitions,
+        functions: [
+            {
+                name: names.openFn,
+                containerTypeName: names.objectType,
+                returnType: 'bool',
+                parameters,
+                mutations: [openMutation],
+                returnExpression: 'self.is_open',
+                invokePolicyJson: policyJson,
+                description: `Open a ${names.objectType}; the invoke policy decides who may.`,
+            },
+            {
+                name: names.closeFn,
+                containerTypeName: names.objectType,
+                returnType: 'bool',
+                parameters,
+                mutations: [closeMutation],
+                returnExpression: 'self.is_open',
+                invokePolicyJson: policyJson,
+                description: `Close a ${names.objectType}; same authority as opening.`,
+            },
+        ],
+    };
+}

package/dist/kit/blueprints/loot.d.ts

@@ -0,0 +1,84 @@
+import { type KitBlueprint, type KitOwnerIdKind, type KitTrustedAuthority } from './core.js';
+/** One weighted entry of a loot table. */
+export interface LootEntrySpec {
+    itemId: string;
+    /** Relative weight (> 0); probabilities are weights normalized per table. */
+    weight: number;
+    /** Minimum quantity granted. Defaults to 1. */
+    minQty?: number;
+    /** Maximum quantity granted. Defaults to `minQty`. */
+    maxQty?: number;
+}
+/** One loot table, unrolled into a single expression at blueprint-build time. */
+export interface LootTableSpec {
+    /** Stable table identifier; also derives the roll function name. */
+    tableId: string;
+    /** 1–16 weighted entries (the expression parser caps chain length). */
+    entries: LootEntrySpec[];
+}
+/** An event-triggered drop: rolls a pooled LootRoll when a model event fires. */
+export interface LootDropSpec {
+    /** Automation name (unique per app), e.g. `'goblin-drop'`. */
+    name: string;
+    /** The table to roll. */
+    tableId: string;
+    /** The model event that triggers the drop (e.g. a `mob_died` function). */
+    onEvent: 'function_invoked' | 'property_changed' | 'container_created';
+    functionName?: string;
+    containerTypeName?: string;
+    propertyKey?: string;
+    debounceMs?: number;
+    /** Rolls per event. Defaults to 1. */
+    maxTargets?: number;
+}
+/** Options for {@link lootBlueprint}. */
+export interface LootBlueprintOptions {
+    /** Prefix for the type/function names. Defaults to none. */
+    typePrefix?: string;
+    /** The loot tables; entries are unrolled into expressions at build time. */
+    tables: LootTableSpec[];
+    /**
+     * Who may roll. Defaults to `'server'` (app admins / studio backend);
+     * automations configured via `drops` may always roll (trusted automations
+     * bypass invoke policies, and the roll functions are marked
+     * `autonomousInvocable` when drops reference their table).
+     */
+    rollAuthority?: KitTrustedAuthority;
+    /**
+     * Event-triggered drops: each rolls an UNROLLED pooled `LootRoll` container
+     * of its table when the event fires (automations mutate — they cannot
+     * create containers — so keep a small pool of pre-created rolls per table).
+     */
+    drops?: LootDropSpec[];
+    /** Owner-mirror typing (see the kit convention). Defaults to `'int'`. */
+    ownerIdKind?: KitOwnerIdKind;
+}
+/** Names derived by {@link lootBlueprint} for a given prefix. */
+export interface LootNames {
+    rollType: string;
+    claimFn: string;
+    /** Snake-cased function-name prefix (empty without a `typePrefix`). */
+    fnPrefix: string;
+}
+/** Compute the type/function names a loot blueprint (and its runtime helper) uses. */
+export declare function lootNames(typePrefix?: string): LootNames;
+/** The roll function name for one table. */
+export declare function lootRollFn(tableId: string, typePrefix?: string): string;
+/**
+ * Blueprint for **loot tables & drops**: weighted tables are unrolled into
+ * pure expressions at blueprint-build time (the expression language is
+ * loop-free), rolled server-side into durable `LootRoll` containers, and
+ * claimed atomically into an item stack. Covers chest rolls, mob drops, and
+ * gacha pulls.
+ *
+ * Flow: create a `LootRoll` (member) for a table → `roll_<table>` (trusted:
+ * server scope by default, or an event automation via `drops`) stores a
+ * single `rand()` seed and resolves item + quantity from it in one
+ * transaction → the owner claims with `claim_roll`, which marks the roll
+ * claimed AND grants the stack in the same invoke (no double-claim, no
+ * client-chosen rewards).
+ *
+ * Runtime counterpart: `client.kit(appId).loot`.
+ */
+export declare function lootBlueprint(options: LootBlueprintOptions): KitBlueprint;
+//# sourceMappingURL=loot.d.ts.map

package/dist/kit/blueprints/loot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loot.d.ts","sourceRoot":"","sources":["../../../src/kit/blueprints/loot.ts"],"names":[],"mappings":"AAIA,OAAO,EAQL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACzB,MAAM,WAAW,CAAC;AAEnB,0CAA0C;AAC1C,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,iFAAiF;AACjF,MAAM,WAAW,aAAa;IAC5B,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,OAAO,EAAE,aAAa,EAAE,CAAC;CAC1B;AAED,iFAAiF;AACjF,MAAM,WAAW,YAAY;IAC3B,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,OAAO,EAAE,kBAAkB,GAAG,kBAAkB,GAAG,mBAAmB,CAAC;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,yCAAyC;AACzC,MAAM,WAAW,oBAAoB;IACnC,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC;;;;OAIG;IACH,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;IACvB,yEAAyE;IACzE,WAAW,CAAC,EAAE,cAAc,CAAC;CAC9B;AAED,iEAAiE;AACjE,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,sFAAsF;AACtF,wBAAgB,SAAS,CAAC,UAAU,SAAK,GAAG,SAAS,CAOpD;AAED,4CAA4C;AAC5C,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,SAAK,GAAG,MAAM,CAGnE;AAwCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,YAAY,CAuLzE"}

package/dist/kit/blueprints/loot.js

@@ -0,0 +1,228 @@
+import { kitPolicyJson, ownerEqualsCaller, ownerMirrorProperty, toSnakeCase, trustedAuthorityFields, } from './core.js';
+/** Compute the type/function names a loot blueprint (and its runtime helper) uses. */
+export function lootNames(typePrefix = '') {
+    const fnPrefix = typePrefix ? `${toSnakeCase(typePrefix)}_` : '';
+    return {
+        rollType: `${typePrefix}LootRoll`,
+        claimFn: `${fnPrefix}claim_roll`,
+        fnPrefix,
+    };
+}
+/** The roll function name for one table. */
+export function lootRollFn(tableId, typePrefix = '') {
+    const fnPrefix = typePrefix ? `${toSnakeCase(typePrefix)}_` : '';
+    return `${fnPrefix}roll_${toSnakeCase(tableId)}`;
+}
+/** Format a probability threshold as an expression float literal. */
+function floatLiteral(n) {
+    const s = String(n);
+    return s.includes('.') || s.includes('e') ? s : `${s}.0`;
+}
+/**
+ * Unroll a weighted table into a nested-if chain over the stored roll seed:
+ * `if(self.seed < t1, "a", if(self.seed < t2, "b", "c"))` with cumulative
+ * normalized thresholds. Expressions are loop-free, so the selection chain
+ * is generated at BUILD time — one `rand()` is stored first and every branch
+ * reads that same seed, keeping the distribution exact.
+ */
+function unrollItemChain(entries) {
+    const total = entries.reduce((sum, e) => sum + e.weight, 0);
+    let expr = JSON.stringify(entries[entries.length - 1].itemId);
+    for (let i = entries.length - 2; i >= 0; i--) {
+        // Threshold below which entries[0..i] win; nested back-to-front.
+        const cumulative = entries.slice(0, i + 1).reduce((sum, e) => sum + e.weight, 0);
+        expr = `if(self.seed < ${floatLiteral(cumulative / total)}, ${JSON.stringify(entries[i].itemId)}, ${expr})`;
+    }
+    return expr;
+}
+/** Unroll the per-item quantity chain, keyed on the already-rolled item id. */
+function unrollQtyChain(entries) {
+    const qtyExpr = (e) => {
+        const min = e.minQty ?? 1;
+        const max = e.maxQty ?? min;
+        return max > min ? `rand_int(${min}, ${max})` : String(min);
+    };
+    let expr = qtyExpr(entries[entries.length - 1]);
+    for (let i = entries.length - 2; i >= 0; i--) {
+        expr = `if(self.rolled_item_id == ${JSON.stringify(entries[i].itemId)}, ${qtyExpr(entries[i])}, ${expr})`;
+    }
+    return expr;
+}
+/**
+ * Blueprint for **loot tables & drops**: weighted tables are unrolled into
+ * pure expressions at blueprint-build time (the expression language is
+ * loop-free), rolled server-side into durable `LootRoll` containers, and
+ * claimed atomically into an item stack. Covers chest rolls, mob drops, and
+ * gacha pulls.
+ *
+ * Flow: create a `LootRoll` (member) for a table → `roll_<table>` (trusted:
+ * server scope by default, or an event automation via `drops`) stores a
+ * single `rand()` seed and resolves item + quantity from it in one
+ * transaction → the owner claims with `claim_roll`, which marks the roll
+ * claimed AND grants the stack in the same invoke (no double-claim, no
+ * client-chosen rewards).
+ *
+ * Runtime counterpart: `client.kit(appId).loot`.
+ */
+export function lootBlueprint(options) {
+    const { typePrefix = '', tables, rollAuthority = 'server', drops = [], ownerIdKind: kind = 'int', } = options;
+    if (!tables.length) {
+        throw new Error('lootBlueprint requires at least one table');
+    }
+    for (const table of tables) {
+        if (table.entries.length < 1 || table.entries.length > 16) {
+            throw new Error(`lootBlueprint table '${table.tableId}' must have 1-16 entries (parser-limit-aware unrolling)`);
+        }
+        if (table.entries.some((e) => !(e.weight > 0))) {
+            throw new Error(`lootBlueprint table '${table.tableId}' entries must have weight > 0`);
+        }
+    }
+    const tableIds = new Set(tables.map((t) => t.tableId));
+    for (const drop of drops) {
+        if (!tableIds.has(drop.tableId)) {
+            throw new Error(`lootBlueprint drop '${drop.name}' references unknown table '${drop.tableId}'`);
+        }
+    }
+    const names = lootNames(typePrefix);
+    const droppedTables = new Set(drops.map((d) => d.tableId));
+    const propertyDefinitions = [
+        ownerMirrorProperty(names.rollType, kind),
+        {
+            containerTypeName: names.rollType,
+            key: 'table_id',
+            valueType: 'string',
+            defaultValueJson: '""',
+            description: 'The loot table this roll draws from.',
+        },
+        {
+            containerTypeName: names.rollType,
+            key: 'seed',
+            valueType: 'float',
+            defaultValueJson: '0',
+            description: 'The stored rand() seed the weighted selection reads (audit-friendly).',
+        },
+        {
+            containerTypeName: names.rollType,
+            key: 'rolled_item_id',
+            valueType: 'string',
+            defaultValueJson: '""',
+            description: 'The rolled item (empty until rolled; a roll cannot re-roll).',
+        },
+        {
+            containerTypeName: names.rollType,
+            key: 'rolled_qty',
+            valueType: 'int',
+            defaultValueJson: '0',
+            description: 'The rolled quantity.',
+        },
+        {
+            containerTypeName: names.rollType,
+            key: 'claimed',
+            valueType: 'bool',
+            defaultValueJson: 'false',
+            description: 'True once claimed into a stack (single-claim guard).',
+        },
+    ];
+    const functions = tables.map((table) => {
+        const auth = trustedAuthorityFields(rollAuthority, `self.table_id == ${JSON.stringify(table.tableId)} && self.rolled_item_id == ""`);
+        return {
+            name: lootRollFn(table.tableId, typePrefix),
+            containerTypeName: names.rollType,
+            returnType: 'string',
+            mutations: [
+                { target: 'self', property: 'seed', expression: 'rand()' },
+                {
+                    target: 'self',
+                    property: 'rolled_item_id',
+                    expression: unrollItemChain(table.entries),
+                },
+                {
+                    target: 'self',
+                    property: 'rolled_qty',
+                    expression: unrollQtyChain(table.entries),
+                },
+            ],
+            returnExpression: 'self.rolled_item_id',
+            ...auth,
+            ...(droppedTables.has(table.tableId) ? { autonomousInvocable: true } : {}),
+            description: `Roll the '${table.tableId}' loot table: stores one rand() seed, then resolves item and quantity from it in one transaction (unrolled weighted selection).`,
+        };
+    });
+    functions.push({
+        name: names.claimFn,
+        containerTypeName: names.rollType,
+        returnType: 'int',
+        parameters: [
+            {
+                name: 'to_stack_id',
+                valueType: 'container_ref',
+                required: true,
+                description: "A caller-owned stack of the rolled item that receives the quantity.",
+            },
+        ],
+        mutations: [
+            { target: 'self', property: 'claimed', expression: 'true' },
+            {
+                target: 'ref($to_stack_id)',
+                property: 'quantity',
+                expression: 'ref($to_stack_id).quantity + self.rolled_qty',
+            },
+        ],
+        returnExpression: 'self.rolled_qty',
+        invokePolicyJson: kitPolicyJson({
+            type: 'condition',
+            expression: [
+                ownerEqualsCaller('self.owner_user_id', kind),
+                'not(self.claimed)',
+                'self.rolled_item_id != ""',
+                'ref($to_stack_id).item_id == self.rolled_item_id',
+                ownerEqualsCaller('ref($to_stack_id).owner_user_id', kind),
+            ].join(' && '),
+        }),
+        description: 'Claim a rolled loot into a stack: the claimed flag and the grant commit atomically, so a roll can never be claimed twice.',
+    });
+    const automations = [];
+    const automationTriggers = [];
+    for (const drop of drops) {
+        automations.push({
+            name: drop.name,
+            functionName: lootRollFn(drop.tableId, typePrefix),
+            targetMode: 'type',
+            targetTypeName: names.rollType,
+            triggerType: 'event',
+            maxTargets: drop.maxTargets ?? 1,
+            selectorJson: JSON.stringify({
+                selfWhere: [
+                    { key: 'table_id', op: '==', value: drop.tableId },
+                    { key: 'rolled_item_id', op: '==', value: '' },
+                ],
+                pick: 'random',
+            }),
+            description: `Event-triggered '${drop.tableId}' drop: rolls a pooled unrolled LootRoll when the event fires.`,
+        });
+        automationTriggers.push({
+            automationName: drop.name,
+            onEvent: drop.onEvent,
+            ...(drop.functionName !== undefined ? { functionName: drop.functionName } : {}),
+            ...(drop.containerTypeName !== undefined
+                ? { containerTypeName: drop.containerTypeName }
+                : {}),
+            ...(drop.propertyKey !== undefined ? { propertyKey: drop.propertyKey } : {}),
+            ...(drop.debounceMs !== undefined ? { debounceMs: drop.debounceMs } : {}),
+        });
+    }
+    return {
+        name: names.rollType,
+        containerTypes: [
+            {
+                typeName: names.rollType,
+                displayName: names.rollType,
+                instantiableBy: 'member',
+                description: 'One durable loot roll: seeded, resolved, and claimed entirely server-side.',
+            },
+        ],
+        propertyDefinitions,
+        functions,
+        ...(automations.length ? { automations, automationTriggers } : {}),
+    };
+}

package/dist/kit/blueprints/matches.d.ts

@@ -0,0 +1,59 @@
+import { type KitBlueprint, type KitOwnerIdKind, type KitTrustedAuthority } from './core.js';
+/** Options for {@link matchesBlueprint}. */
+export interface MatchesBlueprintOptions {
+    /** Prefix for the type/function names. Defaults to none. */
+    typePrefix?: string;
+    /**
+     * Who may submit points to a `Score` row. Defaults to `'host'` (the
+     * elected host referees); use `'server'` or `'automation'` for
+     * server-refereed modes. Never plain players.
+     */
+    scoreAuthority?: KitTrustedAuthority;
+    /**
+     * When set, adds a `turn_tick` interval automation that increments each
+     * active match's `tick_count` — the wall-clock-free timer primitive: store
+     * the tick at turn start and treat `tick_count - turn_started_tick >= N`
+     * as a timeout (there is no `now()` in expressions; counters replace
+     * clocks).
+     */
+    turnTick?: {
+        intervalMs: number;
+    };
+    /** Owner-mirror typing (see the kit convention). Defaults to `'int'`. */
+    ownerIdKind?: KitOwnerIdKind;
+}
+/** Names derived by {@link matchesBlueprint} for a given prefix. */
+export interface MatchesNames {
+    metaType: string;
+    scoreType: string;
+    startFn: string;
+    advanceRoundFn: string;
+    scoreFn: string;
+    endFn: string;
+    turnTickFn: string;
+    turnTickAutomation: string;
+}
+/** Compute the type/function names a matches blueprint (and its runtime helper) uses. */
+export declare function matchesNames(typePrefix?: string): MatchesNames;
+/**
+ * Blueprint for **matches** (lobbies, rounds, turns, scoring) — the
+ * session-layer wrapper every session game needs. Sessions ARE the match
+ * primitive (participants + current turn); this adds a session-scoped
+ * `MatchMeta` (lobby state, round, winner, notification channel) and
+ * per-player `Score` rows.
+ *
+ * Lifecycle functions (`start_match` / `advance_round` / `end_match`) are
+ * creator-or-host gated and declare a **channel notification** — Buddy pings
+ * every channel member post-commit with `"match_changed"`, and clients
+ * re-pull the meta (the notify-to-pull pattern; `kit.matches.onMatchChanged`
+ * wraps the subscription). Turn order itself uses the platform's
+ * `gameModelSetSessionTurn` (the runtime helper calls it — turn authority is
+ * enforced by the service, not an expression).
+ *
+ * End-of-match hooks: attach an event automation to `end_match`
+ * (`function_invoked`) to submit leaderboard scores or adjust ratings.
+ *
+ * Runtime counterpart: `client.kit(appId).matches`.
+ */
+export declare function matchesBlueprint(options?: MatchesBlueprintOptions): KitBlueprint;
+//# sourceMappingURL=matches.d.ts.map

package/dist/kit/blueprints/matches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matches.d.ts","sourceRoot":"","sources":["../../../src/kit/blueprints/matches.ts"],"names":[],"mappings":"AAKA,OAAO,EAML,KAAK,YAAY,EAEjB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACzB,MAAM,WAAW,CAAC;AAEnB,4CAA4C;AAC5C,MAAM,WAAW,uBAAuB;IACtC,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,cAAc,CAAC,EAAE,mBAAmB,CAAC;IACrC;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IAClC,yEAAyE;IACzE,WAAW,CAAC,EAAE,cAAc,CAAC;CAC9B;AAED,oEAAoE;AACpE,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,UAAU,SAAK,GAAG,YAAY,CAY1D;AAaD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,uBAA4B,GAAG,YAAY,CA0NpF"}