convex 1.46.0 → 1.47.0

package/dist/esm-types/cli/lib/deployApi/evaluateSchema.d.ts

@@ -1,23 +1,103 @@
 import { z } from "zod";
-export declare const tableValidationOutcome: z.ZodEnum<["notValidated", "supersetOfEnforced", "supersetOfShape", "mustWalk"]>;
+export declare const tableValidationOutcome: z.ZodEnum<["notValidated", "supersetOfEnforced", "supersetOfStagedValidated", "supersetOfShape", "mustWalk"]>;
 export type TableValidationOutcome = z.infer<typeof tableValidationOutcome>;
 export declare const indexChangePrediction: z.ZodEnum<["added", "identical", "enabled", "disabled", "dropped"]>;
 export type IndexChangePrediction = z.infer<typeof indexChangePrediction>;
+export declare const stagedValidatorState: z.ZodUnion<[z.ZodObject<{
+    state: z.ZodLiteral<"pending">;
+    numDocsValidated: z.ZodNumber;
+    totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "passthrough", z.ZodTypeAny, {
+    state: "pending";
+    numDocsValidated: number;
+    totalDocs?: number | null | undefined;
+}, {
+    state: "pending";
+    numDocsValidated: number;
+    totalDocs?: number | null | undefined;
+}>, z.ZodObject<{
+    state: z.ZodLiteral<"valid">;
+}, "passthrough", z.ZodTypeAny, {
+    state: "valid";
+}, {
+    state: "valid";
+}>, z.ZodObject<{
+    state: z.ZodLiteral<"failed">;
+    error: z.ZodString;
+}, "passthrough", z.ZodTypeAny, {
+    state: "failed";
+    error: string;
+}, {
+    state: "failed";
+    error: string;
+}>]>;
+export type StagedValidatorState = z.infer<typeof stagedValidatorState>;
 export declare const tablePrediction: z.ZodObject<{
     name: z.ZodString;
-    outcome: z.ZodEnum<["notValidated", "supersetOfEnforced", "supersetOfShape", "mustWalk"]>;
+    outcome: z.ZodEnum<["notValidated", "supersetOfEnforced", "supersetOfStagedValidated", "supersetOfShape", "mustWalk"]>;
     numDocs: z.ZodNumber;
     sizeBytes: z.ZodNumber;
+    staged: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"pending">;
+        numDocsValidated: z.ZodNumber;
+        totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, "passthrough", z.ZodTypeAny, {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    }, {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    }>, z.ZodObject<{
+        state: z.ZodLiteral<"valid">;
+    }, "passthrough", z.ZodTypeAny, {
+        state: "valid";
+    }, {
+        state: "valid";
+    }>, z.ZodObject<{
+        state: z.ZodLiteral<"failed">;
+        error: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, {
+        state: "failed";
+        error: string;
+    }, {
+        state: "failed";
+        error: string;
+    }>]>>;
+    canSkipAfterStagedValidation: z.ZodOptional<z.ZodBoolean>;
 }, "passthrough", z.ZodTypeAny, {
     name: string;
-    outcome: "notValidated" | "supersetOfEnforced" | "supersetOfShape" | "mustWalk";
+    outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
     numDocs: number;
     sizeBytes: number;
+    staged?: {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    } | {
+        state: "valid";
+    } | {
+        state: "failed";
+        error: string;
+    } | undefined;
+    canSkipAfterStagedValidation?: boolean | undefined;
 }, {
     name: string;
-    outcome: "notValidated" | "supersetOfEnforced" | "supersetOfShape" | "mustWalk";
+    outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
     numDocs: number;
     sizeBytes: number;
+    staged?: {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    } | {
+        state: "valid";
+    } | {
+        state: "failed";
+        error: string;
+    } | undefined;
+    canSkipAfterStagedValidation?: boolean | undefined;
 }>;
 export type TablePrediction = z.infer<typeof tablePrediction>;
 export declare const indexPrediction: z.ZodIntersection<z.ZodIntersection<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
@@ -85,24 +165,119 @@ export declare const indexPrediction: z.ZodIntersection<z.ZodIntersection<z.ZodD
     needsBackfill: boolean;
 }>>;
 export type IndexPrediction = z.infer<typeof indexPrediction>;
+export declare const discardedStagedValidator: z.ZodObject<{
+    tableName: z.ZodString;
+    state: z.ZodUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"pending">;
+        numDocsValidated: z.ZodNumber;
+        totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, "passthrough", z.ZodTypeAny, {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    }, {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    }>, z.ZodObject<{
+        state: z.ZodLiteral<"valid">;
+    }, "passthrough", z.ZodTypeAny, {
+        state: "valid";
+    }, {
+        state: "valid";
+    }>]>;
+    replaced: z.ZodBoolean;
+}, "passthrough", z.ZodTypeAny, {
+    tableName: string;
+    state: {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    } | {
+        state: "valid";
+    };
+    replaced: boolean;
+}, {
+    tableName: string;
+    state: {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    } | {
+        state: "valid";
+    };
+    replaced: boolean;
+}>;
+export type DiscardedStagedValidator = z.infer<typeof discardedStagedValidator>;
 export declare const componentSchemaPrediction: z.ZodObject<{
     definitionPath: z.ZodString;
     schemaValidation: z.ZodBoolean;
     tables: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
-        outcome: z.ZodEnum<["notValidated", "supersetOfEnforced", "supersetOfShape", "mustWalk"]>;
+        outcome: z.ZodEnum<["notValidated", "supersetOfEnforced", "supersetOfStagedValidated", "supersetOfShape", "mustWalk"]>;
         numDocs: z.ZodNumber;
         sizeBytes: z.ZodNumber;
+        staged: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"pending">;
+            numDocsValidated: z.ZodNumber;
+            totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, "passthrough", z.ZodTypeAny, {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        }, {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        }>, z.ZodObject<{
+            state: z.ZodLiteral<"valid">;
+        }, "passthrough", z.ZodTypeAny, {
+            state: "valid";
+        }, {
+            state: "valid";
+        }>, z.ZodObject<{
+            state: z.ZodLiteral<"failed">;
+            error: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, {
+            state: "failed";
+            error: string;
+        }, {
+            state: "failed";
+            error: string;
+        }>]>>;
+        canSkipAfterStagedValidation: z.ZodOptional<z.ZodBoolean>;
     }, "passthrough", z.ZodTypeAny, {
         name: string;
-        outcome: "notValidated" | "supersetOfEnforced" | "supersetOfShape" | "mustWalk";
+        outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
         numDocs: number;
         sizeBytes: number;
+        staged?: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        } | {
+            state: "failed";
+            error: string;
+        } | undefined;
+        canSkipAfterStagedValidation?: boolean | undefined;
     }, {
         name: string;
-        outcome: "notValidated" | "supersetOfEnforced" | "supersetOfShape" | "mustWalk";
+        outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
         numDocs: number;
         sizeBytes: number;
+        staged?: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        } | {
+            state: "failed";
+            error: string;
+        } | undefined;
+        canSkipAfterStagedValidation?: boolean | undefined;
     }>, "many">;
     indexes: z.ZodArray<z.ZodIntersection<z.ZodIntersection<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         name: z.ZodString;
@@ -168,6 +343,49 @@ export declare const componentSchemaPrediction: z.ZodObject<{
         numDocs: number;
         needsBackfill: boolean;
     }>>, "many">;
+    discardedStagedValidators: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        tableName: z.ZodString;
+        state: z.ZodUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"pending">;
+            numDocsValidated: z.ZodNumber;
+            totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, "passthrough", z.ZodTypeAny, {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        }, {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        }>, z.ZodObject<{
+            state: z.ZodLiteral<"valid">;
+        }, "passthrough", z.ZodTypeAny, {
+            state: "valid";
+        }, {
+            state: "valid";
+        }>]>;
+        replaced: z.ZodBoolean;
+    }, "passthrough", z.ZodTypeAny, {
+        tableName: string;
+        state: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        };
+        replaced: boolean;
+    }, {
+        tableName: string;
+        state: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        };
+        replaced: boolean;
+    }>, "many">>;
 }, "passthrough", z.ZodTypeAny, {
     indexes: ((({
         type: "database";
@@ -194,11 +412,33 @@ export declare const componentSchemaPrediction: z.ZodObject<{
     schemaValidation: boolean;
     tables: {
         name: string;
-        outcome: "notValidated" | "supersetOfEnforced" | "supersetOfShape" | "mustWalk";
+        outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
         numDocs: number;
         sizeBytes: number;
+        staged?: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        } | {
+            state: "failed";
+            error: string;
+        } | undefined;
+        canSkipAfterStagedValidation?: boolean | undefined;
     }[];
     definitionPath: string;
+    discardedStagedValidators?: {
+        tableName: string;
+        state: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        };
+        replaced: boolean;
+    }[] | undefined;
 }, {
     indexes: ((({
         type: "database";
@@ -225,11 +465,33 @@ export declare const componentSchemaPrediction: z.ZodObject<{
     schemaValidation: boolean;
     tables: {
         name: string;
-        outcome: "notValidated" | "supersetOfEnforced" | "supersetOfShape" | "mustWalk";
+        outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
         numDocs: number;
         sizeBytes: number;
+        staged?: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        } | {
+            state: "failed";
+            error: string;
+        } | undefined;
+        canSkipAfterStagedValidation?: boolean | undefined;
     }[];
     definitionPath: string;
+    discardedStagedValidators?: {
+        tableName: string;
+        state: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        };
+        replaced: boolean;
+    }[] | undefined;
 }>;
 export type ComponentSchemaPrediction = z.infer<typeof componentSchemaPrediction>;
 export declare const evaluateSchemaResponse: z.ZodObject<{
@@ -238,19 +500,70 @@ export declare const evaluateSchemaResponse: z.ZodObject<{
         schemaValidation: z.ZodBoolean;
         tables: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
-            outcome: z.ZodEnum<["notValidated", "supersetOfEnforced", "supersetOfShape", "mustWalk"]>;
+            outcome: z.ZodEnum<["notValidated", "supersetOfEnforced", "supersetOfStagedValidated", "supersetOfShape", "mustWalk"]>;
             numDocs: z.ZodNumber;
             sizeBytes: z.ZodNumber;
+            staged: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+                state: z.ZodLiteral<"pending">;
+                numDocsValidated: z.ZodNumber;
+                totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, "passthrough", z.ZodTypeAny, {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            }, {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            }>, z.ZodObject<{
+                state: z.ZodLiteral<"valid">;
+            }, "passthrough", z.ZodTypeAny, {
+                state: "valid";
+            }, {
+                state: "valid";
+            }>, z.ZodObject<{
+                state: z.ZodLiteral<"failed">;
+                error: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, {
+                state: "failed";
+                error: string;
+            }, {
+                state: "failed";
+                error: string;
+            }>]>>;
+            canSkipAfterStagedValidation: z.ZodOptional<z.ZodBoolean>;
         }, "passthrough", z.ZodTypeAny, {
             name: string;
-            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfShape" | "mustWalk";
+            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
             numDocs: number;
             sizeBytes: number;
+            staged?: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            } | {
+                state: "failed";
+                error: string;
+            } | undefined;
+            canSkipAfterStagedValidation?: boolean | undefined;
         }, {
             name: string;
-            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfShape" | "mustWalk";
+            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
             numDocs: number;
             sizeBytes: number;
+            staged?: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            } | {
+                state: "failed";
+                error: string;
+            } | undefined;
+            canSkipAfterStagedValidation?: boolean | undefined;
         }>, "many">;
         indexes: z.ZodArray<z.ZodIntersection<z.ZodIntersection<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
             name: z.ZodString;
@@ -316,6 +629,49 @@ export declare const evaluateSchemaResponse: z.ZodObject<{
             numDocs: number;
             needsBackfill: boolean;
         }>>, "many">;
+        discardedStagedValidators: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tableName: z.ZodString;
+            state: z.ZodUnion<[z.ZodObject<{
+                state: z.ZodLiteral<"pending">;
+                numDocsValidated: z.ZodNumber;
+                totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, "passthrough", z.ZodTypeAny, {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            }, {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            }>, z.ZodObject<{
+                state: z.ZodLiteral<"valid">;
+            }, "passthrough", z.ZodTypeAny, {
+                state: "valid";
+            }, {
+                state: "valid";
+            }>]>;
+            replaced: z.ZodBoolean;
+        }, "passthrough", z.ZodTypeAny, {
+            tableName: string;
+            state: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            };
+            replaced: boolean;
+        }, {
+            tableName: string;
+            state: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            };
+            replaced: boolean;
+        }>, "many">>;
     }, "passthrough", z.ZodTypeAny, {
         indexes: ((({
             type: "database";
@@ -342,11 +698,33 @@ export declare const evaluateSchemaResponse: z.ZodObject<{
         schemaValidation: boolean;
         tables: {
             name: string;
-            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfShape" | "mustWalk";
+            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
             numDocs: number;
             sizeBytes: number;
+            staged?: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            } | {
+                state: "failed";
+                error: string;
+            } | undefined;
+            canSkipAfterStagedValidation?: boolean | undefined;
         }[];
         definitionPath: string;
+        discardedStagedValidators?: {
+            tableName: string;
+            state: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            };
+            replaced: boolean;
+        }[] | undefined;
     }, {
         indexes: ((({
             type: "database";
@@ -373,11 +751,33 @@ export declare const evaluateSchemaResponse: z.ZodObject<{
         schemaValidation: boolean;
         tables: {
             name: string;
-            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfShape" | "mustWalk";
+            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
             numDocs: number;
             sizeBytes: number;
+            staged?: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            } | {
+                state: "failed";
+                error: string;
+            } | undefined;
+            canSkipAfterStagedValidation?: boolean | undefined;
         }[];
         definitionPath: string;
+        discardedStagedValidators?: {
+            tableName: string;
+            state: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            };
+            replaced: boolean;
+        }[] | undefined;
     }>>;
     newComponentDefinitions: z.ZodArray<z.ZodString, "many">;
 }, "passthrough", z.ZodTypeAny, {
@@ -407,11 +807,33 @@ export declare const evaluateSchemaResponse: z.ZodObject<{
         schemaValidation: boolean;
         tables: {
             name: string;
-            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfShape" | "mustWalk";
+            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
             numDocs: number;
             sizeBytes: number;
+            staged?: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            } | {
+                state: "failed";
+                error: string;
+            } | undefined;
+            canSkipAfterStagedValidation?: boolean | undefined;
         }[];
         definitionPath: string;
+        discardedStagedValidators?: {
+            tableName: string;
+            state: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            };
+            replaced: boolean;
+        }[] | undefined;
     }>;
     newComponentDefinitions: string[];
 }, {
@@ -441,11 +863,33 @@ export declare const evaluateSchemaResponse: z.ZodObject<{
         schemaValidation: boolean;
         tables: {
             name: string;
-            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfShape" | "mustWalk";
+            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
             numDocs: number;
             sizeBytes: number;
+            staged?: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            } | {
+                state: "failed";
+                error: string;
+            } | undefined;
+            canSkipAfterStagedValidation?: boolean | undefined;
         }[];
         definitionPath: string;
+        discardedStagedValidators?: {
+            tableName: string;
+            state: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            };
+            replaced: boolean;
+        }[] | undefined;
     }>;
     newComponentDefinitions: string[];
 }>;

package/dist/esm-types/cli/lib/deployApi/evaluateSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evaluateSchema.d.ts","sourceRoot":"","sources":["../../../../../src/cli/lib/deployApi/evaluateSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,sBAAsB,kFAKjC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,qBAAqB,qEAMhC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;EAK1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAO3B,CAAC;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKpC,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,yBAAyB,CACjC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMjC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"evaluateSchema.d.ts","sourceRoot":"","sources":["../../../../../src/cli/lib/deployApi/evaluateSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,sBAAsB,+GAMjC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,qBAAqB,qEAMhC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAI1E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQ/B,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAO3B,CAAC;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAK9D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWnC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOpC,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,yBAAyB,CACjC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMjC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/esm-types/cli/lib/dev.d.ts

@@ -29,6 +29,7 @@ export declare function devAgainstDeployment(ctx: OneoffCtx, credentials: {
     debugNodeApis: boolean;
     liveComponentSources: boolean;
     pushAllModules: boolean;
+    allowUnstagingSchema: boolean;
 }): Promise<undefined>;
 export declare function watchAndPush(outerCtx: OneoffCtx, options: PushOptions, cmdOptions: {
     run?: {

package/dist/esm-types/cli/lib/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../../src/cli/lib/dev.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAarD,OAAO,EAAc,OAAO,EAAa,MAAM,WAAW,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAU9C,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAU1C,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,SAAS,EACd,WAAW,EAAE;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC,EACD,UAAU,EAAE;IACV,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;IACxC,mBAAmB,EAAE,OAAO,CAAC;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,GAAG,CAAC,EACA;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,GAClE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAClC,SAAS,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,aAAa,EAAE,OAAO,CAAC;IACvB,oBAAoB,EAAE,OAAO,CAAC;IAC9B,cAAc,EAAE,OAAO,CAAC;CACzB,sBAgGF;AAED,wBAAsB,YAAY,CAChC,QAAQ,EAAE,SAAS,EACnB,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE;IACV,GAAG,CAAC,EACA;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,GAClE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAClC,SAAS,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;CACtB,iBA0RF;AAoND,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAKxD"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../../src/cli/lib/dev.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAarD,OAAO,EAAc,OAAO,EAAa,MAAM,WAAW,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAU9C,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAU1C,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,SAAS,EACd,WAAW,EAAE;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC,EACD,UAAU,EAAE;IACV,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;IACxC,mBAAmB,EAAE,OAAO,CAAC;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,GAAG,CAAC,EACA;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,GAClE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAClC,SAAS,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,aAAa,EAAE,OAAO,CAAC;IACvB,oBAAoB,EAAE,OAAO,CAAC;IAC9B,cAAc,EAAE,OAAO,CAAC;IACxB,oBAAoB,EAAE,OAAO,CAAC;CAC/B,sBA6GF;AAED,wBAAsB,YAAY,CAChC,QAAQ,EAAE,SAAS,EACnB,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE;IACV,GAAG,CAAC,EACA;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,GAClE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAClC,SAAS,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;CACtB,iBA0RF;AAoND,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAKxD"}

package/dist/esm-types/cli/lib/formatValidationProgress.d.ts

@@ -0,0 +1,8 @@
+import { DiscardedStagedValidator } from "./deployApi/evaluateSchema.js";
+export declare function formatValidationProgress({ numDocsValidated, totalDocs, }: {
+    numDocsValidated: number;
+    totalDocs?: number | null | undefined;
+}): string;
+/** "validated; the push removes the staged validator" */
+export declare function formatDiscardedStagedValidator(validator: DiscardedStagedValidator): string;
+//# sourceMappingURL=formatValidationProgress.d.ts.map

package/dist/esm-types/cli/lib/formatValidationProgress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatValidationProgress.d.ts","sourceRoot":"","sources":["../../../../src/cli/lib/formatValidationProgress.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,wBAAgB,wBAAwB,CAAC,EACvC,gBAAgB,EAChB,SAAS,GACV,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACvC,GAAG,MAAM,CAKT;AAED,yDAAyD;AACzD,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,wBAAwB,GAClC,MAAM,CAeR"}