@azizbekdevuz/gitguard-schema 1.0.0

package/dist/signals.d.ts

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+export declare const SignalsSchema: z.ZodObject<{
+    hasConflicts: z.ZodBoolean;
+    conflictCount: z.ZodNumber;
+    conflictFiles: z.ZodArray<z.ZodString, "many">;
+    isDetachedHead: z.ZodBoolean;
+    detachedAt: z.ZodOptional<z.ZodString>;
+    isRebaseInProgress: z.ZodBoolean;
+    rebaseType: z.ZodEnum<["merge", "apply", "none"]>;
+    rebaseOnto: z.ZodOptional<z.ZodString>;
+    currentBranch: z.ZodString;
+    upstreamBranch: z.ZodOptional<z.ZodString>;
+    aheadCount: z.ZodNumber;
+    behindCount: z.ZodNumber;
+    hasStagedChanges: z.ZodBoolean;
+    hasUnstagedChanges: z.ZodBoolean;
+    hasUntrackedFiles: z.ZodBoolean;
+    recentCheckouts: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        reflogSelector: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string;
+        reflogSelector: string;
+    }, {
+        from: string;
+        to: string;
+        reflogSelector: string;
+    }>, "many">;
+    recentResets: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        target: z.ZodString;
+        reflogSelector: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        reflogSelector: string;
+        target: string;
+    }, {
+        type: string;
+        reflogSelector: string;
+        target: string;
+    }>, "many">;
+    primaryIssue: z.ZodEnum<["merge_conflict", "detached_head", "rebase_in_progress", "clean", "unknown"]>;
+    secondaryIssues: z.ZodArray<z.ZodEnum<["merge_conflict", "detached_head", "rebase_in_progress", "clean", "unknown"]>, "many">;
+    estimatedRisk: z.ZodEnum<["low", "medium", "high"]>;
+}, "strip", z.ZodTypeAny, {
+    isDetachedHead: boolean;
+    hasConflicts: boolean;
+    conflictCount: number;
+    conflictFiles: string[];
+    isRebaseInProgress: boolean;
+    rebaseType: "merge" | "apply" | "none";
+    currentBranch: string;
+    aheadCount: number;
+    behindCount: number;
+    hasStagedChanges: boolean;
+    hasUnstagedChanges: boolean;
+    hasUntrackedFiles: boolean;
+    recentCheckouts: {
+        from: string;
+        to: string;
+        reflogSelector: string;
+    }[];
+    recentResets: {
+        type: string;
+        reflogSelector: string;
+        target: string;
+    }[];
+    primaryIssue: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+    secondaryIssues: ("merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown")[];
+    estimatedRisk: "low" | "medium" | "high";
+    detachedAt?: string | undefined;
+    rebaseOnto?: string | undefined;
+    upstreamBranch?: string | undefined;
+}, {
+    isDetachedHead: boolean;
+    hasConflicts: boolean;
+    conflictCount: number;
+    conflictFiles: string[];
+    isRebaseInProgress: boolean;
+    rebaseType: "merge" | "apply" | "none";
+    currentBranch: string;
+    aheadCount: number;
+    behindCount: number;
+    hasStagedChanges: boolean;
+    hasUnstagedChanges: boolean;
+    hasUntrackedFiles: boolean;
+    recentCheckouts: {
+        from: string;
+        to: string;
+        reflogSelector: string;
+    }[];
+    recentResets: {
+        type: string;
+        reflogSelector: string;
+        target: string;
+    }[];
+    primaryIssue: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+    secondaryIssues: ("merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown")[];
+    estimatedRisk: "low" | "medium" | "high";
+    detachedAt?: string | undefined;
+    rebaseOnto?: string | undefined;
+    upstreamBranch?: string | undefined;
+}>;
+export type Signals = z.infer<typeof SignalsSchema>;
+//# sourceMappingURL=signals.d.ts.map

package/dist/signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../src/signals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCxB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/signals.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { IssueTypeSchema, RiskLevelSchema } from './plan.js';
+// Normalized signals from snapshot for agent processing
+export const SignalsSchema = z.object({
+    // Detected issues
+    hasConflicts: z.boolean(),
+    conflictCount: z.number(),
+    conflictFiles: z.array(z.string()),
+    isDetachedHead: z.boolean(),
+    detachedAt: z.string().optional(), // commit hash
+    isRebaseInProgress: z.boolean(),
+    rebaseType: z.enum(['merge', 'apply', 'none']),
+    rebaseOnto: z.string().optional(),
+    // Branch context
+    currentBranch: z.string(),
+    upstreamBranch: z.string().optional(),
+    aheadCount: z.number(),
+    behindCount: z.number(),
+    // Working tree state
+    hasStagedChanges: z.boolean(),
+    hasUnstagedChanges: z.boolean(),
+    hasUntrackedFiles: z.boolean(),
+    // Recovery hints from reflog
+    recentCheckouts: z.array(z.object({
+        from: z.string(),
+        to: z.string(),
+        reflogSelector: z.string(),
+    })),
+    recentResets: z.array(z.object({
+        type: z.string(), // soft, mixed, hard
+        target: z.string(),
+        reflogSelector: z.string(),
+    })),
+    // Classification result
+    primaryIssue: IssueTypeSchema,
+    secondaryIssues: z.array(IssueTypeSchema),
+    estimatedRisk: RiskLevelSchema,
+});
+//# sourceMappingURL=signals.js.map

package/dist/signals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.js","sourceRoot":"","sources":["../src/signals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE7D,wDAAwD;AACxD,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,kBAAkB;IAClB,YAAY,EAAE,CAAC,CAAC,OAAO,EAAE;IACzB,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IACzB,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAElC,cAAc,EAAE,CAAC,CAAC,OAAO,EAAE;IAC3B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,cAAc;IAEjD,kBAAkB,EAAE,CAAC,CAAC,OAAO,EAAE;IAC/B,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC9C,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAEjC,iBAAiB;IACjB,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IACzB,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IAEvB,qBAAqB;IACrB,gBAAgB,EAAE,CAAC,CAAC,OAAO,EAAE;IAC7B,kBAAkB,EAAE,CAAC,CAAC,OAAO,EAAE;IAC/B,iBAAiB,EAAE,CAAC,CAAC,OAAO,EAAE;IAE9B,6BAA6B;IAC7B,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;QAChC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;QAChB,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;QACd,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE;KAC3B,CAAC,CAAC;IACH,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;QAC7B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,oBAAoB;QACtC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;QAClB,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE;KAC3B,CAAC,CAAC;IAEH,wBAAwB;IACxB,YAAY,EAAE,eAAe;IAC7B,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC;IACzC,aAAa,EAAE,eAAe;CAC/B,CAAC,CAAC"}

package/dist/snapshot.d.ts

@@ -0,0 +1,463 @@
+import { z } from 'zod';
+export declare const ConflictBlockSchema: z.ZodObject<{
+    startLine: z.ZodNumber;
+    endLine: z.ZodNumber;
+    oursContent: z.ZodString;
+    theirsContent: z.ZodString;
+    context: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    startLine: number;
+    endLine: number;
+    oursContent: string;
+    theirsContent: string;
+    context: string;
+}, {
+    startLine: number;
+    endLine: number;
+    oursContent: string;
+    theirsContent: string;
+    context: string;
+}>;
+export type ConflictBlock = z.infer<typeof ConflictBlockSchema>;
+export declare const UnmergedFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    stageOurs: z.ZodOptional<z.ZodString>;
+    stageTheirs: z.ZodOptional<z.ZodString>;
+    stageBase: z.ZodOptional<z.ZodString>;
+    conflictBlocks: z.ZodArray<z.ZodObject<{
+        startLine: z.ZodNumber;
+        endLine: z.ZodNumber;
+        oursContent: z.ZodString;
+        theirsContent: z.ZodString;
+        context: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        startLine: number;
+        endLine: number;
+        oursContent: string;
+        theirsContent: string;
+        context: string;
+    }, {
+        startLine: number;
+        endLine: number;
+        oursContent: string;
+        theirsContent: string;
+        context: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    conflictBlocks: {
+        startLine: number;
+        endLine: number;
+        oursContent: string;
+        theirsContent: string;
+        context: string;
+    }[];
+    stageOurs?: string | undefined;
+    stageTheirs?: string | undefined;
+    stageBase?: string | undefined;
+}, {
+    path: string;
+    conflictBlocks: {
+        startLine: number;
+        endLine: number;
+        oursContent: string;
+        theirsContent: string;
+        context: string;
+    }[];
+    stageOurs?: string | undefined;
+    stageTheirs?: string | undefined;
+    stageBase?: string | undefined;
+}>;
+export type UnmergedFile = z.infer<typeof UnmergedFileSchema>;
+export declare const BranchInfoSchema: z.ZodObject<{
+    head: z.ZodString;
+    oid: z.ZodString;
+    upstream: z.ZodOptional<z.ZodString>;
+    aheadBehind: z.ZodOptional<z.ZodObject<{
+        ahead: z.ZodNumber;
+        behind: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        ahead: number;
+        behind: number;
+    }, {
+        ahead: number;
+        behind: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    head: string;
+    oid: string;
+    upstream?: string | undefined;
+    aheadBehind?: {
+        ahead: number;
+        behind: number;
+    } | undefined;
+}, {
+    head: string;
+    oid: string;
+    upstream?: string | undefined;
+    aheadBehind?: {
+        ahead: number;
+        behind: number;
+    } | undefined;
+}>;
+export type BranchInfo = z.infer<typeof BranchInfoSchema>;
+export declare const ReflogEntrySchema: z.ZodObject<{
+    hash: z.ZodString;
+    selector: z.ZodString;
+    action: z.ZodString;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    hash: string;
+    selector: string;
+    action: string;
+}, {
+    message: string;
+    hash: string;
+    selector: string;
+    action: string;
+}>;
+export type ReflogEntry = z.infer<typeof ReflogEntrySchema>;
+export declare const LogEntrySchema: z.ZodObject<{
+    hash: z.ZodString;
+    refs: z.ZodArray<z.ZodString, "many">;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    hash: string;
+    refs: string[];
+}, {
+    message: string;
+    hash: string;
+    refs: string[];
+}>;
+export type LogEntry = z.infer<typeof LogEntrySchema>;
+export declare const RebaseStateSchema: z.ZodObject<{
+    inProgress: z.ZodBoolean;
+    type: z.ZodEnum<["merge", "apply", "none"]>;
+    headName: z.ZodOptional<z.ZodString>;
+    onto: z.ZodOptional<z.ZodString>;
+    currentStep: z.ZodOptional<z.ZodNumber>;
+    totalSteps: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "merge" | "apply" | "none";
+    inProgress: boolean;
+    headName?: string | undefined;
+    onto?: string | undefined;
+    currentStep?: number | undefined;
+    totalSteps?: number | undefined;
+}, {
+    type: "merge" | "apply" | "none";
+    inProgress: boolean;
+    headName?: string | undefined;
+    onto?: string | undefined;
+    currentStep?: number | undefined;
+    totalSteps?: number | undefined;
+}>;
+export type RebaseState = z.infer<typeof RebaseStateSchema>;
+export declare const DiffStatSchema: z.ZodObject<{
+    path: z.ZodString;
+    additions: z.ZodNumber;
+    deletions: z.ZodNumber;
+    binary: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    additions: number;
+    deletions: number;
+    binary?: boolean | undefined;
+}, {
+    path: string;
+    additions: number;
+    deletions: number;
+    binary?: boolean | undefined;
+}>;
+export type DiffStat = z.infer<typeof DiffStatSchema>;
+export declare const SnapshotV1Schema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    timestamp: z.ZodString;
+    platform: z.ZodEnum<["win32", "darwin", "linux"]>;
+    repoRoot: z.ZodString;
+    gitDir: z.ZodString;
+    branch: z.ZodObject<{
+        head: z.ZodString;
+        oid: z.ZodString;
+        upstream: z.ZodOptional<z.ZodString>;
+        aheadBehind: z.ZodOptional<z.ZodObject<{
+            ahead: z.ZodNumber;
+            behind: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            ahead: number;
+            behind: number;
+        }, {
+            ahead: number;
+            behind: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        head: string;
+        oid: string;
+        upstream?: string | undefined;
+        aheadBehind?: {
+            ahead: number;
+            behind: number;
+        } | undefined;
+    }, {
+        head: string;
+        oid: string;
+        upstream?: string | undefined;
+        aheadBehind?: {
+            ahead: number;
+            behind: number;
+        } | undefined;
+    }>;
+    isDetachedHead: z.ZodBoolean;
+    rebaseState: z.ZodObject<{
+        inProgress: z.ZodBoolean;
+        type: z.ZodEnum<["merge", "apply", "none"]>;
+        headName: z.ZodOptional<z.ZodString>;
+        onto: z.ZodOptional<z.ZodString>;
+        currentStep: z.ZodOptional<z.ZodNumber>;
+        totalSteps: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "merge" | "apply" | "none";
+        inProgress: boolean;
+        headName?: string | undefined;
+        onto?: string | undefined;
+        currentStep?: number | undefined;
+        totalSteps?: number | undefined;
+    }, {
+        type: "merge" | "apply" | "none";
+        inProgress: boolean;
+        headName?: string | undefined;
+        onto?: string | undefined;
+        currentStep?: number | undefined;
+        totalSteps?: number | undefined;
+    }>;
+    unmergedFiles: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        stageOurs: z.ZodOptional<z.ZodString>;
+        stageTheirs: z.ZodOptional<z.ZodString>;
+        stageBase: z.ZodOptional<z.ZodString>;
+        conflictBlocks: z.ZodArray<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            oursContent: z.ZodString;
+            theirsContent: z.ZodString;
+            context: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            startLine: number;
+            endLine: number;
+            oursContent: string;
+            theirsContent: string;
+            context: string;
+        }, {
+            startLine: number;
+            endLine: number;
+            oursContent: string;
+            theirsContent: string;
+            context: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        conflictBlocks: {
+            startLine: number;
+            endLine: number;
+            oursContent: string;
+            theirsContent: string;
+            context: string;
+        }[];
+        stageOurs?: string | undefined;
+        stageTheirs?: string | undefined;
+        stageBase?: string | undefined;
+    }, {
+        path: string;
+        conflictBlocks: {
+            startLine: number;
+            endLine: number;
+            oursContent: string;
+            theirsContent: string;
+            context: string;
+        }[];
+        stageOurs?: string | undefined;
+        stageTheirs?: string | undefined;
+        stageBase?: string | undefined;
+    }>, "many">;
+    stagedFiles: z.ZodArray<z.ZodString, "many">;
+    modifiedFiles: z.ZodArray<z.ZodString, "many">;
+    untrackedFiles: z.ZodArray<z.ZodString, "many">;
+    recentLog: z.ZodArray<z.ZodObject<{
+        hash: z.ZodString;
+        refs: z.ZodArray<z.ZodString, "many">;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        hash: string;
+        refs: string[];
+    }, {
+        message: string;
+        hash: string;
+        refs: string[];
+    }>, "many">;
+    recentReflog: z.ZodArray<z.ZodObject<{
+        hash: z.ZodString;
+        selector: z.ZodString;
+        action: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        hash: string;
+        selector: string;
+        action: string;
+    }, {
+        message: string;
+        hash: string;
+        selector: string;
+        action: string;
+    }>, "many">;
+    commitGraph: z.ZodOptional<z.ZodString>;
+    diffStats: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        additions: z.ZodNumber;
+        deletions: z.ZodNumber;
+        binary: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        additions: number;
+        deletions: number;
+        binary?: boolean | undefined;
+    }, {
+        path: string;
+        additions: number;
+        deletions: number;
+        binary?: boolean | undefined;
+    }>, "many">>;
+    mergeHead: z.ZodOptional<z.ZodString>;
+    mergeMessage: z.ZodOptional<z.ZodString>;
+    rawStatus: z.ZodString;
+    rawBranches: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    timestamp: string;
+    platform: "win32" | "darwin" | "linux";
+    repoRoot: string;
+    gitDir: string;
+    branch: {
+        head: string;
+        oid: string;
+        upstream?: string | undefined;
+        aheadBehind?: {
+            ahead: number;
+            behind: number;
+        } | undefined;
+    };
+    isDetachedHead: boolean;
+    rebaseState: {
+        type: "merge" | "apply" | "none";
+        inProgress: boolean;
+        headName?: string | undefined;
+        onto?: string | undefined;
+        currentStep?: number | undefined;
+        totalSteps?: number | undefined;
+    };
+    unmergedFiles: {
+        path: string;
+        conflictBlocks: {
+            startLine: number;
+            endLine: number;
+            oursContent: string;
+            theirsContent: string;
+            context: string;
+        }[];
+        stageOurs?: string | undefined;
+        stageTheirs?: string | undefined;
+        stageBase?: string | undefined;
+    }[];
+    stagedFiles: string[];
+    modifiedFiles: string[];
+    untrackedFiles: string[];
+    recentLog: {
+        message: string;
+        hash: string;
+        refs: string[];
+    }[];
+    recentReflog: {
+        message: string;
+        hash: string;
+        selector: string;
+        action: string;
+    }[];
+    rawStatus: string;
+    rawBranches: string;
+    commitGraph?: string | undefined;
+    diffStats?: {
+        path: string;
+        additions: number;
+        deletions: number;
+        binary?: boolean | undefined;
+    }[] | undefined;
+    mergeHead?: string | undefined;
+    mergeMessage?: string | undefined;
+}, {
+    version: 1;
+    timestamp: string;
+    platform: "win32" | "darwin" | "linux";
+    repoRoot: string;
+    gitDir: string;
+    branch: {
+        head: string;
+        oid: string;
+        upstream?: string | undefined;
+        aheadBehind?: {
+            ahead: number;
+            behind: number;
+        } | undefined;
+    };
+    isDetachedHead: boolean;
+    rebaseState: {
+        type: "merge" | "apply" | "none";
+        inProgress: boolean;
+        headName?: string | undefined;
+        onto?: string | undefined;
+        currentStep?: number | undefined;
+        totalSteps?: number | undefined;
+    };
+    unmergedFiles: {
+        path: string;
+        conflictBlocks: {
+            startLine: number;
+            endLine: number;
+            oursContent: string;
+            theirsContent: string;
+            context: string;
+        }[];
+        stageOurs?: string | undefined;
+        stageTheirs?: string | undefined;
+        stageBase?: string | undefined;
+    }[];
+    stagedFiles: string[];
+    modifiedFiles: string[];
+    untrackedFiles: string[];
+    recentLog: {
+        message: string;
+        hash: string;
+        refs: string[];
+    }[];
+    recentReflog: {
+        message: string;
+        hash: string;
+        selector: string;
+        action: string;
+    }[];
+    rawStatus: string;
+    rawBranches: string;
+    commitGraph?: string | undefined;
+    diffStats?: {
+        path: string;
+        additions: number;
+        deletions: number;
+        binary?: boolean | undefined;
+    }[] | undefined;
+    mergeHead?: string | undefined;
+    mergeMessage?: string | undefined;
+}>;
+export type SnapshotV1 = z.infer<typeof SnapshotV1Schema>;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../src/snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAM9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAGhE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAG9D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAG1D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;EAK5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAG5D,eAAO,MAAM,cAAc;;;;;;;;;;;;EAIzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAGtD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;EAO5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAG5D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EAKzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAGtD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqC3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}