@happyvertical/smrt-fields 0.40.61 → 0.40.63

package/dist/models/FieldPolicySuggestion.d.ts

@@ -0,0 +1,132 @@
+import { SmrtObject, SmrtObjectOptions } from '@happyvertical/smrt-core';
+import { FieldPolicySuggestionData, FieldPolicySuggestionKind, FieldPolicySuggestionStatus } from '../types.js';
+/**
+ * `activeKey` sentinel for the single ACTIVE (pending) suggestion per
+ * `(objectRef, fieldName, tenantId, kind)`. Settled rows key themselves by id,
+ * so history never competes for the slot.
+ */
+export declare const ACTIVE_SUGGESTION_KEY = "active";
+export interface FieldPolicySuggestionOptions extends SmrtObjectOptions {
+    objectRef?: string;
+    fieldName?: string;
+    tenantId?: string;
+    kind?: FieldPolicySuggestionKind;
+    proposedValue?: string | null;
+    evidence?: string;
+    status?: FieldPolicySuggestionStatus;
+    cooldownUntil?: Date | null;
+    decidedBy?: string | null;
+    decidedAt?: Date | null;
+}
+/**
+ * A pending, human-reviewable field-policy improvement proposed from real
+ * usage (epic #2045, issue #2051): promote a field to the `basic` tier, or
+ * seed an org default with the dominant observed value.
+ *
+ * Suggestion-first by design — a row DOES NOTHING until a
+ * `fields.policy.manage` holder accepts it, and acceptance writes the
+ * org-scope {@link ../models/FieldPolicy.FieldPolicy} row through NORMAL
+ * validation (registry check, type check, security rail, required-field
+ * invariant, ownership + permission split). Dismissing sets a cool-down that
+ * suppresses regeneration of the same suggestion.
+ *
+ * **One ACTIVE suggestion per identity, structurally** (not merely by a
+ * check-then-insert): {@link activeKey} is a computed column holding the
+ * sentinel {@link ACTIVE_SUGGESTION_KEY} while the row is `pending` and the
+ * row's own id once it settles, and it participates in `conflictColumns`. The
+ * unique index therefore admits at most ONE pending row per
+ * `(objectRef, fieldName, tenantId, kind)` while every settled row keys
+ * itself — so two overlapping generation runs (e.g. a global and a
+ * tenant-specific schedule) UPSERT onto the same row instead of duplicating,
+ * with no transaction spanning their reads. It is the `FieldPolicy.scopeKey`
+ * trick applied to a lifecycle slot. On settle the column flips to the row's
+ * id, which frees the slot for a post-cool-down regeneration while keeping the
+ * dismissed/accepted history (and its id) intact — core conflicts a persisted
+ * row on its primary key (#1472), so the flip is a plain UPDATE.
+ *
+ * #1885 seam: this substrate is fully independent of personas'
+ * `DirectiveProposal` review queue (no shared producer discriminator —
+ * deliberately out of scope). Tenant learning agents MAY create
+ * FieldPolicySuggestion rows through this model's normal validation; the
+ * reviewed `fields.policy.manage` acceptance gate is unchanged by who
+ * proposed.
+ */
+export declare class FieldPolicySuggestion extends SmrtObject {
+    /** Qualified class name of the target object (`@package/name:ClassName`). */
+    objectRef: string;
+    /** Field name on the target object (validated against the registry). */
+    fieldName: string;
+    /** Owning tenant (required — suggestions always target one org). */
+    tenantId?: string;
+    /** What the suggestion proposes ('promote' | 'default'). */
+    kind: FieldPolicySuggestionKind;
+    /**
+     * JSON-encoded proposed default (`kind: 'default'` only) — the exact
+     * encoding `FieldPolicy.defaultValue` stores, so acceptance passes it
+     * through unchanged. NULL for `promote`.
+     */
+    proposedValue: string | null;
+    /**
+     * Human-readable evidence as a JSON string: a `summary` sentence plus the
+     * structured window/threshold numbers behind it (see
+     * `buildFieldUsageEvidence`).
+     */
+    evidence: string;
+    /** Lifecycle status ('pending' | 'accepted' | 'dismissed'). */
+    status: FieldPolicySuggestionStatus;
+    /**
+     * Computed lifecycle-slot key, set in `save()`: {@link ACTIVE_SUGGESTION_KEY}
+     * while `pending`, else the row's own id. It exists ONLY to make the
+     * `conflictColumns` unique index express "at most one ACTIVE suggestion per
+     * identity, unlimited settled history" (the `FieldPolicy.scopeKey`
+     * precedent) — never read it for logic; `status` owns that.
+     */
+    activeKey: string;
+    /**
+     * Until this instant, a dismissed suggestion suppresses regeneration of the
+     * same `(objectRef, fieldName, tenantId, kind)` suggestion. NULL until
+     * dismissed.
+     */
+    cooldownUntil: Date | null;
+    /** Who accepted/dismissed (audit attribution, #2050); not validated. */
+    decidedBy: string | null;
+    /** When the suggestion was accepted/dismissed. */
+    decidedAt: Date | null;
+    constructor(options?: FieldPolicySuggestionOptions);
+    /** Parse the stored evidence object (guarded; junk parses as empty). */
+    getEvidence(): Record<string, unknown>;
+    /** Serialize an evidence object into the stored JSON string. */
+    setEvidence(evidence: Record<string, unknown>): void;
+    /** Parse the proposed value; `undefined` when none is stored. */
+    getProposedValue(): unknown;
+    /** Serialized row shape for the collection actions. */
+    toSuggestionData(): FieldPolicySuggestionData;
+    save(): Promise<this>;
+    /**
+     * Recompute the lifecycle-slot key: the shared sentinel while pending (so
+     * the unique index admits exactly one), the row's own id once settled (so
+     * history never competes for the slot and the freed slot allows a
+     * post-cool-down regeneration). A settled row that has not been persisted
+     * yet is assigned its id here — the key must be unique from the first write.
+     */
+    private applyActiveKey;
+    delete(): Promise<void>;
+    /**
+     * The "normal validation" the #1885 seam promises producers: registry-known
+     * field, policy-addressable, never sensitive/read-permission-gated/transient
+     * (those fields are count-only in usage data and get no suggestions), valid
+     * kind/status, and for `default` suggestions a JSON proposed value that
+     * type-checks against the manifest field type.
+     */
+    private validateFieldPolicySuggestion;
+    /**
+     * Tenant write boundary (the FieldPolicy posture): inside a non-bypass
+     * tenant context a caller may only touch its own tenant's suggestions —
+     * checked against BOTH the in-memory scope and, for persisted rows, the
+     * PERSISTED tenant (a foreign row cannot be re-scoped into the caller's
+     * tenant). Trusted execution (no context / bypass) is exempt — that is what
+     * lets the scheduled generation job and platform flows operate.
+     */
+    private assertRowOwnedByAmbientContext;
+}
+//# sourceMappingURL=FieldPolicySuggestion.d.ts.map

package/dist/models/FieldPolicySuggestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldPolicySuggestion.d.ts","sourceRoot":"","sources":["../../src/models/FieldPolicySuggestion.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,UAAU,EACV,KAAK,iBAAiB,EAEvB,MAAM,0BAA0B,CAAC;AAclC,OAAO,EAGL,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EACjC,MAAM,aAAa,CAAC;AAErB;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,WAAW,CAAC;AAE9C,MAAM,WAAW,4BAA6B,SAAQ,iBAAiB;IACrE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,yBAAyB,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,2BAA2B,CAAC;IACrC,aAAa,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IAC5B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAOH,qBAaa,qBAAsB,SAAQ,UAAU;IACnD,6EAA6E;IAE7E,SAAS,EAAE,MAAM,CAAM;IAEvB,wEAAwE;IAExE,SAAS,EAAE,MAAM,CAAM;IAEvB,oEAAoE;IAEpE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,4DAA4D;IAE5D,IAAI,EAAE,yBAAyB,CAAa;IAE5C;;;;OAIG;IAEH,aAAa,EAAE,MAAM,GAAG,IAAI,CAAQ;IAEpC;;;;OAIG;IAEH,QAAQ,EAAE,MAAM,CAAQ;IAExB,+DAA+D;IAE/D,MAAM,EAAE,2BAA2B,CAAa;IAEhD;;;;;;OAMG;IAEH,SAAS,EAAE,MAAM,CAAyB;IAE1C;;;;OAIG;IAEH,aAAa,EAAE,IAAI,GAAG,IAAI,CAAQ;IAElC,wEAAwE;IAExE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAQ;IAEhC,kDAAkD;IAElD,SAAS,EAAE,IAAI,GAAG,IAAI,CAAQ;gBAElB,OAAO,GAAE,4BAAiC;IAkBtD,wEAAwE;IACxE,WAAW,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAWtC,gEAAgE;IAChE,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAIpD,iEAAiE;IACjE,gBAAgB,IAAI,OAAO;IAW3B,uDAAuD;IACvD,gBAAgB,IAAI,yBAAyB;IAgB9B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAOpC;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAWP,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtC;;;;;;OAMG;YACW,6BAA6B;IAiF3C;;;;;;;OAOG;YACW,8BAA8B;CAyC7C"}

package/dist/models/FieldUsageCounter.d.ts

@@ -0,0 +1,178 @@
+import { SmrtObject, SmrtObjectOptions } from '@happyvertical/smrt-core';
+/**
+ * Cap on distinct-user ids stored per bucket. For threshold questions
+ * ("did at least N distinct users set this field?") the capped set is EXACT up
+ * to the cap; once overflowed, {@link FieldUsageCounter.distinctUserCount} is
+ * an honest LOWER BOUND that trivially satisfies any threshold ≤ the cap.
+ */
+export declare const MAX_DISTINCT_USERS_PER_BUCKET = 100;
+/** Cap on histogram buckets per counter row (bounded storage). */
+export declare const MAX_VALUE_HISTOGRAM_BUCKETS = 25;
+/** Longest histogram key recorded; longer samples are skipped (count-only). */
+export declare const MAX_VALUE_HISTOGRAM_KEY_LENGTH = 64;
+/** `period` bucket format: UTC calendar day. */
+export declare const FIELD_USAGE_PERIOD_PATTERN: RegExp;
+/** The UTC day bucket for a timestamp (`YYYY-MM-DD`). */
+export declare function fieldUsagePeriodForDate(date: Date): string;
+/**
+ * A prototype-free histogram map.
+ *
+ * Histogram keys are user-supplied values (an `idType: 'text'` reference id may
+ * legitimately be `constructor`, `toString`, or `__proto__`). On a plain object
+ * those either resolve to inherited members — making an absent bucket look
+ * present and corrupting its count — or, for `__proto__`, invoke the prototype
+ * setter instead of creating an own key. A null-prototype object has no such
+ * members, so every key behaves like data. Use this everywhere histogram counts
+ * are accumulated (storage AND merge paths).
+ */
+export declare function emptyHistogram(): Record<string, number>;
+export interface FieldUsageCounterOptions extends SmrtObjectOptions {
+    objectRef?: string;
+    fieldName?: string;
+    tenantId?: string;
+    period?: string;
+    submissionCount?: number;
+    setCount?: number;
+    distinctUserCount?: number;
+    distinctUserIds?: string;
+    distinctUsersOverflowed?: boolean;
+    valueHistogram?: string | null;
+    valueHistogramOverflowed?: boolean;
+}
+/**
+ * Period-bucketed field usage counter (epic #2045, issue #2051).
+ *
+ * One row aggregates field submissions for a single
+ * `(objectRef, fieldName, tenantId, period)` — the substrate the
+ * suggestion-generation job reads. Counters are deliberately APPROXIMATE:
+ * ingestion is fire-and-forget and concurrent bucket merges may lose an
+ * increment (read-modify-write), which is acceptable for usage statistics and
+ * documented here rather than papered over.
+ *
+ * TWO counters, because they answer different questions:
+ * - {@link submissionCount} — EVERY observed submission of the field
+ *   (default-matching or not). It is the denominator for value dominance:
+ *   "N% of submissions used value V". Without it, a value seen only in
+ *   deviations would look 100% dominant even against thousands of
+ *   default-valued submissions.
+ * - {@link setCount} — submissions whose value DIFFERED from the resolved
+ *   default (server-derived). It plus {@link distinctUserIds} is the
+ *   promote signal ("real users are actively filling this in").
+ *
+ * Content rails (enforced by the ingestion action, which derives everything
+ * from the live registry and never trusts the client):
+ * - Sensitive and read-permission-gated fields are COUNT-ONLY: their raw
+ *   values are never recorded anywhere in usage data — not even for
+ *   default-matching submissions.
+ * - Value histograms exist only for low-cardinality field types (`boolean`,
+ *   `foreignKey`, `crossPackageRef`) — never free text, even non-sensitive
+ *   text (PII risk) — with a bounded bucket count and key length. They cover
+ *   ALL submissions (not just deviations) so the dominance ratio is a true
+ *   fraction of {@link submissionCount}.
+ * - `distinctUserIds` is a capped set with an overflow marker (see
+ *   {@link MAX_DISTINCT_USERS_PER_BUCKET} for the honesty contract).
+ */
+export declare class FieldUsageCounter extends SmrtObject {
+    /** Qualified class name of the target object (`@package/name:ClassName`). */
+    objectRef: string;
+    /** Field name on the target object. */
+    fieldName: string;
+    /**
+     * Owning tenant. REQUIRED: ingestion fails closed without an ambient tenant
+     * context, so every row is attributable (and the conflict-column tuple
+     * stays total). Native UUID on PostgreSQL/DuckDB.
+     */
+    tenantId?: string;
+    /** UTC day bucket (`YYYY-MM-DD`); lexicographic order is time order. */
+    period: string;
+    /**
+     * EVERY observed submission of this field in the bucket, whether or not the
+     * value matched the resolved default — the dominance denominator.
+     *
+     * Rows written before this column existed carry `0` while `setCount > 0`;
+     * {@link isLegacyBucket} detects that shape and the generation job then
+     * treats the total as UNKNOWN and skips `default` suggestions for the group
+     * (promote, which needs no denominator, still works).
+     */
+    submissionCount: number;
+    /**
+     * Submissions whose value DIFFERED from the server-resolved default (the
+     * promote signal). Always `<= submissionCount` on rows written by the
+     * current ingestion path.
+     */
+    setCount: number;
+    /**
+     * Size of the stored distinct-user set. When
+     * {@link distinctUsersOverflowed} is true this is a LOWER BOUND (the set is
+     * capped), never an estimate.
+     */
+    distinctUserCount: number;
+    /** JSON array of distinct user ids, capped (see the class doc). */
+    distinctUserIds: string;
+    /** True once a distinct user was NOT added because the set is at its cap. */
+    distinctUsersOverflowed: boolean;
+    /**
+     * JSON object `serializedValue -> count` for histogram-eligible fields;
+     * NULL when the field is count-only. Keys are bounded in number and length.
+     */
+    valueHistogram: string | null;
+    /** True once a sample was dropped because the bucket cap was reached. */
+    valueHistogramOverflowed: boolean;
+    constructor(options?: FieldUsageCounterOptions);
+    /** Parse the stored distinct-user set (guarded; junk parses as empty). */
+    getDistinctUserIds(): string[];
+    /**
+     * Add a user to the distinct set, honoring the cap. At the cap the id is
+     * NOT added and the overflow marker is set instead, keeping
+     * {@link distinctUserCount} an honest lower bound.
+     */
+    addDistinctUser(userId: string): void;
+    /**
+     * Parse the stored histogram (guarded; junk parses as empty).
+     *
+     * Returns a NULL-PROTOTYPE object. Histogram keys are user-supplied ids —
+     * an `idType: 'text'` reference may legitimately be `constructor`,
+     * `toString`, or `__proto__` — and on a plain object those inherit truthy
+     * prototype values (so a missing bucket reads as present) or, for
+     * `__proto__`, hit the prototype setter instead of creating an own key.
+     * Both would silently corrupt counts. See {@link emptyHistogram}.
+     */
+    getValueHistogram(): Record<string, number>;
+    /**
+     * Record one histogram sample under an already-serialized key, honoring the
+     * bucket cap (a NEW key past the cap is dropped and the overflow marker
+     * set; existing keys keep counting).
+     *
+     * Bucket presence is an OWN-key test, never a truthiness/`undefined` read,
+     * so prototype-shaped ids behave like any other key.
+     */
+    recordHistogramSample(key: string): void;
+    /**
+     * Whether this bucket predates the {@link submissionCount} column (or was
+     * corrupted): it records deviations without a total, so no honest dominance
+     * ratio can be computed from it. The generation job skips `default`
+     * suggestions for any group containing such a bucket.
+     */
+    isLegacyBucket(): boolean;
+    save(): Promise<this>;
+    delete(): Promise<void>;
+    private validateFieldUsageCounter;
+    /**
+     * Tenant write boundary (the FieldPolicy posture — no class-level
+     * `@TenantScoped`, because the learning jobs legitimately operate
+     * cross-tenant in trusted execution): inside a non-bypass tenant context a
+     * caller may only touch rows of its own tenant; without a context (system/
+     * job execution) writes are trusted.
+     *
+     * Checked against BOTH the in-memory tenant and — for a row that already
+     * exists — the PERSISTED one. The persisted check is what makes the boundary
+     * real: bucket ids are deterministic and the deriving helper is exported, so
+     * a foreign row is trivially addressable, and an in-memory-only check would
+     * let a caller load it, re-stamp `tenantId` with its own, and adopt or delete
+     * another tenant's counters (the #2047 FieldPolicy pattern).
+     */
+    private assertRowOwnedByAmbientContext;
+    /** The stored tenant for this row's id; `null` when it is not persisted. */
+    private getPersistedTenantId;
+}
+//# sourceMappingURL=FieldUsageCounter.d.ts.map

package/dist/models/FieldUsageCounter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldUsageCounter.d.ts","sourceRoot":"","sources":["../../src/models/FieldUsageCounter.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,UAAU,EACV,KAAK,iBAAiB,EAEvB,MAAM,0BAA0B,CAAC;AAQlC;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,MAAM,CAAC;AAEjD,kEAAkE;AAClE,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAE9C,+EAA+E;AAC/E,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAEjD,gDAAgD;AAChD,eAAO,MAAM,0BAA0B,QAAwB,CAAC;AAEhE,yDAAyD;AACzD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE1D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEvD;AAED,MAAM,WAAW,wBAAyB,SAAQ,iBAAiB;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAMH,qBAOa,iBAAkB,SAAQ,UAAU;IAC/C,6EAA6E;IAE7E,SAAS,EAAE,MAAM,CAAM;IAEvB,uCAAuC;IAEvC,SAAS,EAAE,MAAM,CAAM;IAEvB;;;;OAIG;IAEH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,wEAAwE;IAExE,MAAM,EAAE,MAAM,CAAM;IAEpB;;;;;;;;OAQG;IAEH,eAAe,EAAE,MAAM,CAAK;IAE5B;;;;OAIG;IAEH,QAAQ,EAAE,MAAM,CAAK;IAErB;;;;OAIG;IAEH,iBAAiB,EAAE,MAAM,CAAK;IAE9B,mEAAmE;IAEnE,eAAe,EAAE,MAAM,CAAQ;IAE/B,6EAA6E;IAE7E,uBAAuB,EAAE,OAAO,CAAS;IAEzC;;;OAGG;IAEH,cAAc,EAAE,MAAM,GAAG,IAAI,CAAQ;IAErC,yEAAyE;IAEzE,wBAAwB,EAAE,OAAO,CAAS;gBAE9B,OAAO,GAAE,wBAA6B;IA2BlD,0EAA0E;IAC1E,kBAAkB,IAAI,MAAM,EAAE;IAW9B;;;;OAIG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAcrC;;;;;;;;;OASG;IACH,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAwB3C;;;;;;;OAOG;IACH,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAiBxC;;;;;OAKG;IACH,cAAc,IAAI,OAAO;IAIV,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAMrB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtC,OAAO,CAAC,yBAAyB;IAoCjC;;;;;;;;;;;;;OAaG;YACW,8BAA8B;IAgC5C,4EAA4E;YAC9D,oBAAoB;CAYnC"}

package/dist/models/FieldUsageReportReceipt.d.ts

@@ -0,0 +1,25 @@
+import { SmrtObject, SmrtObjectOptions } from '@happyvertical/smrt-core';
+/**
+ * Durable daily receipt for one member's contribution to one field.
+ *
+ * The counter action creates this before incrementing its aggregate. Its
+ * natural key makes the anti-inflation rule durable across requests and
+ * replicas: one `(tenant, user, object, field, UTC day)` sample may affect
+ * usage evidence. Receipts intentionally retain no submitted value.
+ */
+export declare class FieldUsageReportReceipt extends SmrtObject {
+    tenantId?: string;
+    userId: string;
+    objectRef: string;
+    fieldName: string;
+    period: string;
+    constructor(options?: FieldUsageReportReceiptOptions);
+}
+export interface FieldUsageReportReceiptOptions extends SmrtObjectOptions {
+    tenantId?: string;
+    userId?: string;
+    objectRef?: string;
+    fieldName?: string;
+    period?: string;
+}
+//# sourceMappingURL=FieldUsageReportReceipt.d.ts.map

package/dist/models/FieldUsageReportReceipt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldUsageReportReceipt.d.ts","sourceRoot":"","sources":["../../src/models/FieldUsageReportReceipt.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,UAAU,EACV,KAAK,iBAAiB,EAEvB,MAAM,0BAA0B,CAAC;AAGlC;;;;;;;GAOG;AACH,qBAaa,uBAAwB,SAAQ,UAAU;IAErD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAGlB,MAAM,EAAE,MAAM,CAAM;IAGpB,SAAS,EAAE,MAAM,CAAM;IAGvB,SAAS,EAAE,MAAM,CAAM;IAGvB,MAAM,EAAE,MAAM,CAAM;gBAER,OAAO,GAAE,8BAAmC;CAQzD;AAED,MAAM,WAAW,8BAA+B,SAAQ,iBAAiB;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}