convex 1.46.0 → 1.48.0-alpha.0

package/dist/cjs-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/cjs-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/cjs-types/cli/lib/deployKeyWarning.d.ts

@@ -0,0 +1,3 @@
+import { Context } from "../../bundler/context.js";
+export declare function warnIfDeployKeyOverridesLogin(ctx: Context, hasAccount: boolean): void;
+//# sourceMappingURL=deployKeyWarning.d.ts.map

package/dist/cjs-types/cli/lib/deployKeyWarning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployKeyWarning.d.ts","sourceRoot":"","sources":["../../../../src/cli/lib/deployKeyWarning.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAcnD,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,OAAO,QA0BpB"}

package/dist/cjs-types/cli/lib/deployment.d.ts

@@ -13,6 +13,7 @@ export declare function writeDeploymentEnvVar(ctx: Context, deploymentType: Depl
     changedDeploymentEnvVar: boolean;
 }>;
 export declare function eraseDeploymentEnvVar(ctx: Context): Promise<boolean>;
+export declare function gitIgnoreEnvVarFile(ctx: Context): Promise<boolean>;
 export declare function changesToEnvVarFile(existingFile: string | null, deploymentType: DeploymentType, { team, project, deploymentName, }: {
     team: string | null;
     project: string | null;
@@ -20,6 +21,7 @@ export declare function changesToEnvVarFile(existingFile: string | null, deploym
 }): string | null;
 export declare function changesToGitIgnore(existingFile: string | null): string | null;
 export declare function deploymentNameFromAdminKeyOrCrash(ctx: Context, adminKey: string): Promise<string>;
+export declare function deploymentNameFromAdminKey(adminKey: string): string | null;
 export declare function isPreviewDeployKey(adminKey: string): boolean;
 export declare function isProjectKey(adminKey: string): boolean;
 export declare function isDeploymentKey(adminKey: string): boolean;

package/dist/cjs-types/cli/lib/deployment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deployment.d.ts","sourceRoot":"","sources":["../../../../src/cli/lib/deployment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAOnD,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAK1C,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,UAE3D;AAGD,wBAAgB,yCAAyC,CAAC,GAAG,EAAE,MAAM,+CAUpE;AAED,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,WAE3D;AAED,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,UAK3D;AAED,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,OAAO,EACZ,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE;IACV,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,EACD,aAAa,EAAE,MAAM,GAAG,IAAI,GAC3B,OAAO,CAAC;IAAE,gBAAgB,EAAE,OAAO,CAAC;IAAC,uBAAuB,EAAE,OAAO,CAAA;CAAE,CAAC,CA+B1E;AAGD,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAkB1E;AAgBD,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,cAAc,EAAE,cAAc,EAC9B,EACE,IAAI,EACJ,OAAO,EACP,cAAc,GACf,EAAE;IAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACzE,MAAM,GAAG,IAAI,CAcf;AAGD,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CA4B7E;AAED,wBAAsB,iCAAiC,CACrD,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,MAAM,mBAWjB;AAkBD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,WAQlD;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,WAE5C;AAID,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,WAE/C;AAUD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,kBAM1D;AAED,wBAAsB,oCAAoC,CACxD,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,MAAM;;;GAajB;AAED,MAAM,MAAM,qBAAqB,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AACxD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC"}
+{"version":3,"file":"deployment.d.ts","sourceRoot":"","sources":["../../../../src/cli/lib/deployment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAOnD,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAK1C,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,UAE3D;AAGD,wBAAgB,yCAAyC,CAAC,GAAG,EAAE,MAAM,+CAUpE;AAED,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,WAE3D;AAED,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,UAK3D;AAED,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,OAAO,EACZ,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE;IACV,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,EACD,aAAa,EAAE,MAAM,GAAG,IAAI,GAC3B,OAAO,CAAC;IAAE,gBAAgB,EAAE,OAAO,CAAC;IAAC,uBAAuB,EAAE,OAAO,CAAA;CAAE,CAAC,CA+B1E;AAGD,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAkB1E;AAED,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAWxE;AAGD,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,cAAc,EAAE,cAAc,EAC9B,EACE,IAAI,EACJ,OAAO,EACP,cAAc,GACf,EAAE;IAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACzE,MAAM,GAAG,IAAI,CAcf;AAGD,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CA4B7E;AAED,wBAAsB,iCAAiC,CACrD,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,MAAM,mBAWjB;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,iBAU1D;AAMD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,WAQlD;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,WAE5C;AAID,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,WAE/C;AAUD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,kBAM1D;AAED,wBAAsB,oCAAoC,CACxD,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,MAAM;;;GAajB;AAED,MAAM,MAAM,qBAAqB,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AACxD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC"}

package/dist/cjs-types/cli/lib/deploymentSelection.d.ts

@@ -1,6 +1,7 @@
 import { ProjectResponse } from "@convex-dev/platform/managementApi";
 import { Context } from "../../bundler/context.js";
 import { AccountRequiredDeploymentType, DeploymentSelectionOptions, DeploymentSelectionWithinProject, DeploymentType } from "./api.js";
+import { ProfileSelection } from "./profiles.js";
 /**
  * The auth header can be a few different things:
  * * An access token (corresponds to device authorization, usually stored in `~/.convex/config.json`)
@@ -27,7 +28,7 @@ export declare function initializeBigBrainAuth(ctx: Context, initialArgs: {
     adminKey?: string | undefined;
     envFile?: string | undefined;
 }): Promise<void>;
-export declare function updateBigBrainAuthAfterLogin(ctx: Context, accessToken: string): Promise<void>;
+export declare function updateBigBrainAuthAfterLogin(ctx: Context, accessToken: string, profile?: ProfileSelection): Promise<void>;
 export declare function clearBigBrainAuth(ctx: Context): Promise<void>;
 /** Crashes unless logged in with a personal access token (not a deploy key). */
 export declare function ensureLoggedInWithAccessToken(ctx: Context, action: string): Promise<void>;