@prisma/migrate 6.7.0-dev.8 → 6.7.0-dev.9

package/dist/internals/src/Generator.d.ts

@@ -1,42 +0,0 @@
-import type { BinaryPaths, Generator as IGenerator, GeneratorConfig, GeneratorManifest, GeneratorOptions } from '@prisma/generator';
-export declare abstract class Generator {
-    manifest: GeneratorManifest | null;
-    config: GeneratorConfig;
-    options?: GeneratorOptions;
-    constructor(config: GeneratorConfig);
-    init(): Promise<void>;
-    protected abstract initImpl(): Promise<void>;
-    protected abstract getManifest(): Promise<GeneratorManifest | null>;
-    abstract stop(): void;
-    generate(): Promise<void>;
-    protected abstract generateImpl(options: GeneratorOptions): Promise<void>;
-    setOptions(options: GeneratorOptions): void;
-    setBinaryPaths(binaryPaths: BinaryPaths): void;
-    /**
-     * Returns the pretty name of the generator specified in the manifest (e.g.,
-     * "Prisma Client"), or, if the former is not defined, the generator's
-     * provider name (e.g., "prisma-client-js") as a fallback.
-     */
-    getPrettyName(): string;
-    /**
-     * Returns the provider name, parsed and resolved from environment variable
-     * if necessary.
-     */
-    getProvider(): string;
-}
-export declare class JsonRpcGenerator extends Generator {
-    #private;
-    constructor(executablePath: string, config: GeneratorConfig, isNode?: boolean);
-    protected initImpl(): Promise<void>;
-    protected getManifest(): Promise<GeneratorManifest | null>;
-    protected generateImpl(options: GeneratorOptions): Promise<void>;
-    stop(): void;
-}
-export declare class InProcessGenerator extends Generator {
-    #private;
-    constructor(config: GeneratorConfig, generator: IGenerator);
-    protected initImpl(): Promise<void>;
-    protected getManifest(): Promise<GeneratorManifest | null>;
-    protected generateImpl(options: GeneratorOptions): Promise<void>;
-    stop(): void;
-}

package/dist/internals/src/WasmPanicRegistry.d.ts

@@ -1,5 +0,0 @@
-export declare class WasmPanicRegistry {
-    private message;
-    get(): string;
-    private set_message;
-}

package/dist/internals/src/WasmSchemaEngineLoader.d.ts

@@ -1,5 +0,0 @@
-import type { ErrorCapturingSqlDriverAdapterFactory } from '@prisma/driver-adapter-utils';
-import type { ConstructorOptions, SchemaEngine } from '@prisma/schema-engine-wasm';
-export declare const wasmSchemaEngineLoader: {
-    loadSchemaEngine(input: ConstructorOptions, debug: (arg: string) => void, adapter: ErrorCapturingSqlDriverAdapterFactory): Promise<SchemaEngine>;
-};

package/dist/internals/src/cli/Help.d.ts

@@ -1,11 +0,0 @@
-/**
- * Unknown command
- */
-export declare function unknownCommand(helpTemplate: string, cmd: string): HelpError;
-/**
- * Custom help error used to display help
- * errors without printing a stack trace
- */
-export declare class HelpError extends Error {
-    constructor(msg: string);
-}

package/dist/internals/src/cli/checkUnsupportedDataProxy.d.ts

@@ -1,18 +0,0 @@
-import { SchemaContext } from '..';
-/**
- * Get the message to display when a command is forbidden with a data proxy flag
- * @param command the cli command (eg. db push)
- * @returns
- */
-export declare const forbiddenCmdWithDataProxyFlagMessage: (command: string) => string;
-/**
- * Check that the data proxy cannot be used through the given urls and schema contexts
- * @param command the cli command (eg. db push)
- * @param urls list of urls to check
- * @param schemaContexts list of schema contexts to check
- */
-export declare function checkUnsupportedDataProxy({ cmd, schemaContext, urls, }: {
-    cmd: string;
-    schemaContext?: SchemaContext;
-    urls?: (string | undefined)[];
-}): void;

package/dist/internals/src/cli/checkUnsupportedSchemaEngineWasm.d.ts

@@ -1,22 +0,0 @@
-import { PrismaConfigInternal } from '@prisma/config';
-/**
- * Get the message to display when a command is forbidden with a data proxy flag
- * @param command the cli command (eg. db push)
- * @returns
- */
-export declare const forbiddenCmdFlagWithSchemaEngineWasm: ({ cmd, flag }: {
-    cmd: string;
-    flag: string;
-}) => string;
-/**
- * Check that the data proxy cannot be used through the given urls and schema contexts
- * @param command the cli command (eg. db push)
- * @param urls list of urls to check
- * @param schemaContexts list of schema contexts to check
- */
-export declare function checkUnsupportedSchemaEngineWasm({ cmd, config, args, flags, }: {
-    cmd: string;
-    config: PrismaConfigInternal<any>;
-    args: Record<string, unknown>;
-    flags: Array<string>;
-}): void;

package/dist/internals/src/cli/directoryConfig.d.ts

@@ -1,7 +0,0 @@
-import { SchemaContext } from './schemaContext';
-export type DirectoryConfig = {
-    viewsDirPath: string;
-    typedSqlDirPath: string;
-    migrationsDirPath: string;
-};
-export declare function inferDirectoryConfig(schemaContext?: SchemaContext | null, cwd?: string): DirectoryConfig;

package/dist/internals/src/cli/getGeneratorSuccessMessage.d.ts

@@ -1,7 +0,0 @@
-import type { Generator } from '../Generator';
-/**
- * Creates and formats the success message for the given generator to print to
- * the console after generation finishes.
- * @param time time in milliseconds it took for the generator to run.
- */
-export declare function getGeneratorSuccessMessage(generator: Generator, time: number): string;

package/dist/internals/src/cli/getTypescriptVersion.d.ts

@@ -1 +0,0 @@
-export declare function getTypescriptVersion(): Promise<string>;

package/dist/internals/src/cli/hashes.d.ts

@@ -1,10 +0,0 @@
-/**
- * Get a unique identifier for the project by hashing
- * the directory with `schema.prisma`
- */
-export declare function getProjectHash(schemaPathFromArgs: string | undefined, schemaPathFromConfig: string | undefined): Promise<string>;
-/**
- * Get a unique identifier for the CLI installation path
- * which can be either global or local (in project's node_modules)
- */
-export declare function getCLIPathHash(): string;

package/dist/internals/src/cli/schemaContext.d.ts

@@ -1,59 +0,0 @@
-import { DataSource, GeneratorConfig } from '@prisma/generator';
-import { GetSchemaResult, LoadedFile } from '@prisma/schema-files-loader';
-export type SchemaContext = {
-    /**
-     * All loaded schema files and their paths.
-     */
-    schemaFiles: LoadedFile[];
-    /**
-     * The root directory of the schema files.
-     * Either set explicitly from a schema folder based config or the parent directory of the schema.prisma file.
-     */
-    schemaRootDir: string;
-    /**
-     * The directory of the schema.prisma file that contains the datasource block.
-     * Some relative paths like SQLite paths or SSL file paths are resolved relative to it.
-     */
-    primaryDatasourceDirectory: string;
-    /**
-     * The path that shall be printed in user facing logs messages informing them from where the schema was loaded.
-     */
-    loadedFromPathForLogMessages: string;
-    /**
-     * The datasource extracted from the Prisma schema. So far we only support a single datasource block.
-     */
-    primaryDatasource: DataSource | undefined;
-    /**
-     * Warnings that were raised during Prisma schema parsing.
-     */
-    warnings: string[] | [];
-    /**
-     * The datasources extracted from the Prisma schema. Prefer to use primaryDatasource for most cases.
-     */
-    datasources: DataSource[] | [];
-    /**
-     * The generators extracted from the Prisma schema.
-     */
-    generators: GeneratorConfig[] | [];
-    schemaPath: string;
-};
-type LoadSchemaContextOptions = {
-    schemaPathFromArg?: string;
-    schemaPathFromConfig?: string;
-    printLoadMessage?: boolean;
-    ignoreEnvVarErrors?: boolean;
-    allowNull?: boolean;
-    schemaPathArgumentName?: string;
-    cwd?: string;
-};
-export declare function loadSchemaContext(opts: LoadSchemaContextOptions & {
-    allowNull: true;
-}): Promise<SchemaContext | null>;
-export declare function loadSchemaContext(opts?: LoadSchemaContextOptions): Promise<SchemaContext>;
-export declare function processSchemaResult({ schemaResult, printLoadMessage, ignoreEnvVarErrors, cwd, }: {
-    schemaResult: GetSchemaResult;
-    printLoadMessage?: boolean;
-    ignoreEnvVarErrors?: boolean;
-    cwd?: string;
-}): Promise<SchemaContext>;
-export {};

package/dist/internals/src/cli/types.d.ts

@@ -1,47 +0,0 @@
-import type { PrismaConfigInternal } from '@prisma/config';
-/**
- * Command interface
- */
-export interface Command {
-    parse(argv: string[], config: PrismaConfigInternal): Promise<string | Error>;
-}
-/**
- * Commands
- */
-export type Commands = {
-    [command: string]: Command;
-};
-export type Dictionary<T> = {
-    [key: string]: T;
-};
-export type GeneratorConfig = {
-    output: string | null;
-    name: string;
-    provider: string;
-    config: Dictionary<string>;
-    binaryTargets: string[];
-    pinnedBinaryTargets?: string | null;
-};
-export type GeneratorOptions = {
-    generator: GeneratorConfig;
-    otherGenerators: GeneratorConfig[];
-    cwd: string;
-    dmmf: any;
-    datasources: any;
-    datamodel: string;
-};
-export type GeneratorFunction = (options: GeneratorOptions) => Promise<string>;
-export type GeneratorDefinition = {
-    prettyName?: string;
-    generate: GeneratorFunction;
-    defaultOutput: string;
-};
-export type GeneratorDefinitionWithPackage = {
-    definition: GeneratorDefinition;
-    packagePath: string;
-};
-export type CompiledGeneratorDefinition = {
-    prettyName?: string;
-    output?: string | null;
-    generate: () => Promise<string>;
-};

package/dist/internals/src/cli/utils.d.ts

@@ -1,13 +0,0 @@
-import Arg from 'arg';
-/**
- * format
- */
-export declare function format(input?: string): string;
-/**
- * Wrap arg to return an error instead of throwing
- */
-export declare function arg<T extends Arg.Spec>(argv: string[], spec: T, stopAtPositional?: boolean, permissive?: boolean): Arg.Result<T> | Error;
-/**
- * Check if result is an error
- */
-export declare function isError(result: any): result is Error;

package/dist/internals/src/client/getClientEngineType.d.ts

@@ -1,8 +0,0 @@
-import type { GeneratorConfig } from '@prisma/generator';
-export declare enum ClientEngineType {
-    Library = "library",
-    Binary = "binary",
-    Client = "client"
-}
-export declare const DEFAULT_CLIENT_ENGINE_TYPE = ClientEngineType.Library;
-export declare function getClientEngineType(generatorConfig?: GeneratorConfig): ClientEngineType;

package/dist/internals/src/convertCredentials.d.ts

@@ -1,10 +0,0 @@
-import type { ConnectorType } from '@prisma/generator';
-import type { DatabaseCredentials } from './types';
-export declare function credentialsToUri(credentials: DatabaseCredentials): string;
-export declare function uriToCredentials(connectionString: string): DatabaseCredentials;
-/**
- * Convert a protocol to the equivalent database connector type.
- * Throws an error if the protocol is not recognized.
- * @param protocol e.g., 'postgres:'
- */
-export declare function protocolToConnectorType(protocol: string): ConnectorType;

package/dist/internals/src/dotenvExpand.d.ts

@@ -1,35 +0,0 @@
-import type { DotenvConfigOutput } from 'dotenv';
-/**
- * Modified version of https://github.com/motdotla/dotenv-expand
- * Our version does only expand ${ENV} - curly braces but not without curly braces
- *
- * Original License from https://github.com/motdotla/dotenv-expand/blob/de9e5cb0215495452f475f5be4dea1580b8217cd/LICENSE
- * Copyright (c) 2016, Scott Motte
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * * Redistributions of source code must retain the above copyright notice, this
- *  list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright notice,
- *  this list of conditions and the following disclaimer in the documentation
- *  and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-export declare function dotenvExpand(config: DotenvConfigOutput & {
-    ignoreProcessEnv?: boolean;
-}): DotenvConfigOutput & {
-    ignoreProcessEnv?: boolean | undefined;
-};

package/dist/internals/src/engine-commands/errorHelpers.d.ts

@@ -1,4 +0,0 @@
-/**
- * Adds `Prisma CLI Version : x.x.x` at the bottom of the error output.
- */
-export declare function addVersionDetailsToErrorMessage(message: string): string;

package/dist/internals/src/engine-commands/formatSchema.d.ts

@@ -1,22 +0,0 @@
-import { type MultipleSchemas } from '../utils/schemaFileInput';
-type FormatSchemaParams = {
-    schemas: MultipleSchemas;
-};
-export declare function formatSchema({ schemas }: FormatSchemaParams, inputFormattingOptions?: Partial<DocumentFormattingParams['options']>): Promise<MultipleSchemas>;
-type DocumentUri = string;
-type TextDocument = {
-    /**
-     * The associated URI for this document. Most documents have the __file__-scheme, indicating that they
-     * represent files on disk. However, some documents may have other schemes indicating that they are not
-     * available on disk.
-     */
-    readonly uri: DocumentUri;
-};
-type DocumentFormattingParams = {
-    textDocument: TextDocument;
-    options: {
-        tabSize: number;
-        insertSpaces: boolean;
-    };
-};
-export {};

package/dist/internals/src/engine-commands/getConfig.d.ts

@@ -1,31 +0,0 @@
-import type { DataSource, EnvValue, GeneratorConfig } from '@prisma/generator';
-import { type SchemaFileInput } from '../utils/schemaFileInput';
-import { QueryEngineErrorInit } from './queryEngineCommons';
-export interface GetConfigResponse {
-    config: ConfigMetaFormat;
-    errors: GetConfigValidationError[];
-}
-export interface ConfigMetaFormat {
-    datasources: DataSource[] | [];
-    generators: GeneratorConfig[] | [];
-    warnings: string[] | [];
-}
-interface GetConfigValidationError {
-    fileName: string | null;
-    message: string;
-}
-export type GetConfigOptions = {
-    datamodel: SchemaFileInput;
-    ignoreEnvVarErrors?: boolean;
-};
-export declare class GetConfigError extends Error {
-    constructor(params: QueryEngineErrorInit);
-}
-export declare function getEffectiveUrl(ds: DataSource): EnvValue;
-export declare function getDirectUrl(ds: DataSource): EnvValue | undefined;
-export declare function resolveUrl(envValue: EnvValue | undefined): string | undefined;
-/**
- * Wasm'd version of `getConfig`.
- */
-export declare function getConfig(options: GetConfigOptions): Promise<ConfigMetaFormat>;
-export {};

package/dist/internals/src/engine-commands/getDmmf.d.ts

@@ -1,20 +0,0 @@
-import type * as DMMF from '@prisma/dmmf';
-import type { DataSource, GeneratorConfig } from '@prisma/generator';
-import { type SchemaFileInput } from '../utils/schemaFileInput';
-import { QueryEngineErrorInit } from './queryEngineCommons';
-export interface ConfigMetaFormat {
-    datasources: DataSource[];
-    generators: GeneratorConfig[];
-    warnings: string[];
-}
-export type GetDMMFOptions = {
-    datamodel: SchemaFileInput;
-    previewFeatures?: string[];
-};
-export declare class GetDmmfError extends Error {
-    constructor(params: QueryEngineErrorInit);
-}
-/**
- * Wasm'd version of `getDMMF`.
- */
-export declare function getDMMF(options: GetDMMFOptions): Promise<DMMF.Document>;

package/dist/internals/src/engine-commands/getEngineVersion.d.ts

@@ -1,4 +0,0 @@
-import { BinaryType } from '@prisma/fetch-engine';
-import * as TE from 'fp-ts/TaskEither';
-export declare function getEngineVersion(enginePath?: string, binaryName?: BinaryType): Promise<string>;
-export declare function safeGetEngineVersion(enginePath?: string, binaryName?: BinaryType): TE.TaskEither<Error, string>;

package/dist/internals/src/engine-commands/getEnginesMetaInfo.d.ts

@@ -1,25 +0,0 @@
-import { BinaryType } from '@prisma/fetch-engine';
-import * as E from 'fp-ts/Either';
-import * as O from 'fp-ts/Option';
-/**
- * Both an engine binary and a library might be resolved from and environment variable indicating a path.
- * We first try to retrieve the engines' path from an env var; if it fails, we fall back to `safeResolveBinary`.
- * If both fail, we return an error.
- * Even if we resolve a path, retrieving the version might fail.
- */
-export type EngineInfo = {
-    fromEnvVar: O.Option<string>;
-    path: E.Either<Error, string>;
-    version: E.Either<Error, string>;
-};
-export type BinaryMatrix<T> = {
-    'query-engine': T;
-    'schema-engine': T;
-};
-export type BinaryInfoMatrix = BinaryMatrix<EngineInfo>;
-export declare function getEnginesMetaInfo(): Promise<readonly [{
-    'query-engine': string;
-    'schema-engine': string;
-}[], Error[]]>;
-export declare function getEnginesInfo(enginesInfo: EngineInfo): readonly [string, Error[]];
-export declare function resolveEngine(binaryName: BinaryType): Promise<EngineInfo>;

package/dist/internals/src/engine-commands/index.d.ts

@@ -1,10 +0,0 @@
-export { formatSchema } from './formatSchema';
-export type { ConfigMetaFormat } from './getConfig';
-export { getConfig, getDirectUrl, getEffectiveUrl } from './getConfig';
-export type { GetDMMFOptions } from './getDmmf';
-export { getDMMF } from './getDmmf';
-export { getEnginesMetaInfo } from './getEnginesMetaInfo';
-export { getEngineVersion } from './getEngineVersion';
-export { getLintWarningsAsText, handleLintPanic, lintSchema } from './lintSchema';
-export { mergeSchemas } from './mergeSchemas';
-export { validate } from './validate';

package/dist/internals/src/engine-commands/lintSchema.d.ts

@@ -1,26 +0,0 @@
-import { type MultipleSchemas } from '../utils/schemaFileInput';
-type LintSchemaParams = {
-    schemas: MultipleSchemas;
-};
-type LintDiagnosticBase = {
-    start: number;
-    end: number;
-    text: string;
-};
-export type LintWarning = {
-    is_warning: true;
-} & LintDiagnosticBase;
-export type LintError = {
-    is_warning: false;
-} & LintDiagnosticBase;
-export type LintDiagnostic = LintWarning | LintError;
-/**
- * Diagnose the given schema, returning a list either errors or warnings.
- * This function may panic, but it won't throw any standard error.
- */
-export declare function lintSchema({ schemas }: LintSchemaParams): LintDiagnostic[];
-export declare function handleLintPanic<T>(tryCb: () => T): T;
-export declare function getLintWarnings(lintDiagnostics: LintDiagnostic[]): LintWarning[];
-export declare function getLintWarningsAsText(lintDiagnostics: LintDiagnostic[]): string;
-export declare function warningToString(warning: LintDiagnostic): string;
-export {};

package/dist/internals/src/engine-commands/mergeSchemas.d.ts

@@ -1,12 +0,0 @@
-import { type MultipleSchemas } from '../utils/schemaFileInput';
-import { QueryEngineErrorInit } from './queryEngineCommons';
-export type MergeSchemasOptions = {
-    schemas: MultipleSchemas;
-};
-export declare class MergeSchemasError extends Error {
-    constructor(params: QueryEngineErrorInit);
-}
-/**
- * Wasm'd version of `merge_schemas`.
- */
-export declare function mergeSchemas(options: MergeSchemasOptions): string;

package/dist/internals/src/engine-commands/queryEngineCommons.d.ts

@@ -1,31 +0,0 @@
-import * as TE from 'fp-ts/TaskEither';
-export declare function unlinkTempDatamodelPath(options: {
-    datamodelPath?: string;
-}, tempDatamodelPath: string | undefined): TE.TaskEither<{
-    type: string;
-    reason: string;
-    error: unknown;
-}, void>;
-export declare const createDebugErrorType: (debug: (formatter: any, ...args: any[]) => void, fnName: string) => ({ type, reason, error }: {
-    type: string;
-    reason: string;
-    error: Error;
-}) => void;
-export declare function createSchemaValidationError(reason: string): string;
-export type QueryEngineErrorInit = {
-    reason: string;
-    message: string;
-} & ({
-    readonly _tag: 'parsed';
-    errorCode?: string;
-} | {
-    readonly _tag: 'unparsed';
-});
-export type ParseQueryEngineError = {
-    errorOutput: string;
-    reason: string;
-};
-/**
- * Parse the error output of getConfig / getDmmf, which follow the format convention of the query-engine methods.
- */
-export declare function parseQueryEngineError({ errorOutput, reason }: ParseQueryEngineError): QueryEngineErrorInit;

package/dist/internals/src/engine-commands/relativizePathInPSLError.d.ts

@@ -1 +0,0 @@
-export declare function relativizePathInPSLError(error: string): string;

package/dist/internals/src/engine-commands/validate.d.ts

@@ -1,12 +0,0 @@
-import { type MultipleSchemas } from '../utils/schemaFileInput';
-import { QueryEngineErrorInit } from './queryEngineCommons';
-export type ValidateOptions = {
-    schemas: MultipleSchemas;
-};
-export declare class ValidateError extends Error {
-    constructor(params: QueryEngineErrorInit);
-}
-/**
- * Wasm'd version of `validate`.
- */
-export declare function validate(options: ValidateOptions): void;

package/dist/internals/src/errorReporting.d.ts

@@ -1,25 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { ErrorArea } from './panic';
-export declare enum ErrorKind {
-    JS_ERROR = "JS_ERROR",
-    RUST_PANIC = "RUST_PANIC"
-}
-export interface CreateErrorReportInput {
-    area: ErrorArea;
-    binaryVersion: string;
-    cliVersion: string;
-    command: string;
-    jsStackTrace: string;
-    kind: ErrorKind;
-    liftRequest?: string;
-    operatingSystem: string;
-    platform: string;
-    rustStackTrace: string;
-    fingerprint?: string;
-    sqlDump?: string;
-    dbVersion?: string;
-}
-export declare function uploadZip(zip: Buffer, url: string): Promise<any>;
-export declare function createErrorReport(data: CreateErrorReportInput): Promise<string>;
-export declare function makeErrorReportCompleted(signedUrl: string): Promise<number>;

package/dist/internals/src/get-generators/getGenerators.d.ts

@@ -1,71 +0,0 @@
-import type { BinaryTargetsEnvValue, EngineType, Generator as IGenerator, GeneratorConfig, SqlQueryOutput } from '@prisma/generator';
-import type { BinaryTarget } from '@prisma/get-platform';
-import { SchemaContext } from '..';
-import { Generator } from '../Generator';
-type BinaryPathsOverride = {
-    [P in EngineType]?: string;
-};
-export type GeneratorRegistryEntry = {
-    type: 'rpc';
-    generatorPath: string;
-    isNode?: boolean;
-} | {
-    type: 'in-process';
-    generator: IGenerator;
-};
-export type GeneratorRegistry = Record<string, GeneratorRegistryEntry>;
-export type ProviderAliases = {
-    [alias: string]: {
-        generatorPath: string;
-        isNode?: boolean;
-    };
-};
-export type GetGeneratorOptions = {
-    /** @deprecated Pass a schemaContext instead. Kept for compatibility with prisma studio. */
-    schemaPath?: string;
-    schemaContext?: SchemaContext;
-    registry: GeneratorRegistry;
-    /** @deprecated Use `registry` instead. Kept for compatibility with Prisma Studio. */
-    providerAliases?: ProviderAliases;
-    version?: string;
-    printDownloadProgress?: boolean;
-    overrideGenerators?: GeneratorConfig[];
-    skipDownload?: boolean;
-    binaryPathsOverride?: BinaryPathsOverride;
-    generatorNames?: string[];
-    postinstall?: boolean;
-    noEngine?: boolean;
-    allowNoModels?: boolean;
-    typedSql?: SqlQueryOutput[];
-};
-/**
- * Makes sure that all generators have the binaries they deserve and returns a
- * `Generator` class per generator defined in the schema.prisma file.
- * In other words, this is basically a generator factory function.
- */
-export declare function getGenerators(options: GetGeneratorOptions): Promise<Generator[]>;
-type NeededVersions = {
-    [key: string]: {
-        engines: EngineType[];
-        binaryTargets: BinaryTargetsEnvValue[];
-    };
-};
-export type GetBinaryPathsByVersionInput = {
-    neededVersions: NeededVersions;
-    binaryTarget: BinaryTarget;
-    version?: string;
-    printDownloadProgress?: boolean;
-    skipDownload?: boolean;
-    binaryPathsOverride?: BinaryPathsOverride;
-};
-/**
- * Shortcut for getGenerators, if there is only one generator defined. Useful for testing.
- * @param schemaPath path to schema.prisma
- * @param aliases Aliases like `photonjs` -> `node_modules/photonjs/gen.js`
- * @param version Version of the binary, commit hash of https://github.com/prisma/prisma-engine/commits/master
- * @param printDownloadProgress `boolean` to print download progress or not
- */
-export declare function getGenerator(options: GetGeneratorOptions): Promise<Generator>;
-export declare function skipIndex<T = any>(arr: T[], index: number): T[];
-export declare const knownBinaryTargets: BinaryTarget[];
-export {};

package/dist/internals/src/get-generators/utils/binaryTypeToEngineType.d.ts

@@ -1,3 +0,0 @@
-import { BinaryType } from '@prisma/fetch-engine';
-import type { EngineType } from '@prisma/generator';
-export declare function binaryTypeToEngineType(binaryType: BinaryType): EngineType;

package/dist/internals/src/get-generators/utils/engineTypeToBinaryType.d.ts

@@ -1,3 +0,0 @@
-import { BinaryType } from '@prisma/fetch-engine';
-import type { EngineType } from '@prisma/generator';
-export declare function engineTypeToBinaryType(engineType: EngineType): BinaryType;

package/dist/internals/src/get-generators/utils/fixBinaryTargets.d.ts

@@ -1,3 +0,0 @@
-import { BinaryTargetsEnvValue } from '@prisma/generator';
-import { BinaryTarget } from '@prisma/get-platform';
-export declare function fixBinaryTargets(schemaBinaryTargets: BinaryTargetsEnvValue[], runtimeBinaryTarget: BinaryTarget | string): BinaryTargetsEnvValue[];