@prisma/security-rules 0.3.6

package/dist/index.d.cts

@@ -0,0 +1,276 @@
+import * as _prisma_client_extension from '@prisma/client/extension';
+import { Prisma as Prisma$1 } from '@prisma/client/extension';
+import { Prisma } from '@prisma/client/scripts/default-index.js';
+import * as _prisma_client_runtime_library from '@prisma/client/runtime/library';
+import * as _prisma_extension_pulse_workerd from '@prisma/extension-pulse/workerd';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+/// <reference lib="dom" />
+
+interface PrismaCacheStrategy {
+    /**
+     * Specifies the caching parameters for Accelerate.
+     *
+     * `cacheStrategy` only applies when used with an Accelerate connection string.
+     */
+    readonly cacheStrategy?: {
+        /**
+         * `swr` is short for Stale-While-Revalidate.
+         *
+         * `swr` defines the number of seconds that Accelerate may serve _stale_ cache data.
+         * _Stale_ data is a cache hit, but the cache will be refreshed in the background by Accelerate.
+         * The Prisma operation will not be blocked while data is refreshed.
+         *
+         * Use `swr` to reduce the latency of accessing the data while still maintaining
+         * a more up-to-date value in the Accelerate cache.
+         * `swr` without `ttl` will not reduce database load since Accelerate will
+         * run the query in the background.
+         *
+         * `swr` can be combined with `ttl`.
+         * `swr` applies **after** `ttl` has expired.
+         * The total number of seconds data will be cached is `ttl + swr`.
+         *
+         * `swr` only applies when used with an Accelerate connection string.
+         */
+        readonly swr?: number;
+        /**
+         * `ttl` is short for Time-to-Live.
+         *
+         * `ttl` defines the number of seconds that Accelerate may serve _fresh_ cache data.
+         * _Fresh_ data is a cache hit and will not execute the query against the database.
+         *
+         * Use `ttl` to reduce database load and latency for data that does not
+         * require frequent updates.
+         * `ttl` without `swr` will incur a blocking database query for the first
+         * request after `ttl` expires.
+         *
+         * It's recommended to combine `ttl` and `swr` to maintain low latency while
+         * Accelerate refreshes cached data in the background.
+         * `swr` applies **after** `ttl` has expired.
+         * The total number of seconds data will be cached is `ttl + swr`.
+         *
+         * `ttl` only applies when used with an Accelerate connection string.
+         */
+        readonly ttl?: number;
+        /**
+         * `tags` allow you to attach string values to the query's cache entry
+         * that can later be used to invalidate the cache.
+         *
+         * A tag may only contain alphanumeric characters and underscores.
+         * Each tag may contain a maximum of 64 characters.
+         * A maximum of 5 tags are allowed per query.
+         */
+        readonly tags?: ReadonlyArray<string>;
+    };
+}
+interface AccelerateInfo {
+    /**
+     * The cache status of the response.
+     * * `ttl` indicates a cache hit within the `ttl` duration and no database query was executed
+     * * `swr` indicates a cache hit within the `swr` duration and the data is being refreshed by Accelerate in the background
+     * * `miss` indicates that both `ttl` and `swr` have expired and the database query was executed by the request
+     * * `none` indicates that no cache strategy was specified and the database query was executed by the request
+     */
+    cacheStatus: "ttl" | "swr" | "miss" | "none";
+    /**
+     * The date the response was last refreshed.
+     */
+    lastModified: Date;
+    /**
+     * The datacenter region that received the request.
+     */
+    region: string;
+    /**
+     * Unique identifier of the request. Useful for troubleshooting.
+     */
+    requestId: string;
+    /**
+     * The unique signature of the Prisma operation.
+     */
+    signature: string;
+}
+type AccelerateInvalidateInput = {
+    /** Invalidate cache by tags set in the query `cacheStrategy`. */
+    tags: ReadonlyArray<string>;
+};
+interface AcceleratePromise<T> extends Prisma.PrismaPromise<T> {
+    withAccelerateInfo(): Prisma.PrismaPromise<{
+        data: T;
+        info: AccelerateInfo | null;
+    }>;
+}
+
+type CoerceAnyToNever<T> = unknown extends T ? never : T;
+type CoerceNeverToValue<T, V> = [T] extends [never] ? V : T;
+type ModelKeys<T> = {
+    [K in keyof T]: K extends `$${string}` ? never : K;
+}[keyof T];
+type Rules<C, Ctx extends StandardSchemaV1, AllModelKeys extends ModelKeys<C> = ModelKeys<C>> = {
+    [K in AllModelKeys]?: {
+        pulse?: PulseRuleShape<C, K, Ctx>;
+        read?: OpRuleShape<ReadOperation, C, K, Ctx>;
+        create?: OpRuleShape<CreateOperation, C, K, Ctx>;
+        delete?: OpRuleShape<DeleteOperation, C, K, Ctx>;
+        update?: OpRuleShape<UpdateOperation, C, K, Ctx>;
+        $allOperations?: OpRuleShape<Operation, C, K, Ctx>;
+    } | boolean;
+} & {
+    $transaction?: boolean;
+    $allModels?: {
+        pulse?: AnyPulseRuleShape<Ctx>;
+        read?: AnyOpRuleShape<ReadOperation, Ctx>;
+        create?: AnyOpRuleShape<CreateOperation, Ctx>;
+        delete?: AnyOpRuleShape<DeleteOperation, Ctx>;
+        update?: AnyOpRuleShape<UpdateOperation, Ctx>;
+        $allOperations?: AnyOpRuleShape<Operation, Ctx>;
+    } | boolean;
+};
+/** <Pulse> */
+/** <Pulse:Model> */
+type PulseRuleShape<C, K extends keyof C, Ctx extends StandardSchemaV1> = boolean | PulseRuleShapeStatic<C, K> | PulseRuleShapeCallback<C, K, Ctx>;
+type PulseWhere<C, K extends keyof C> = Partial<Pick<Prisma$1.Args<C[K], "findMany">["where"], keyof Prisma$1.Payload<C[K], "findMany">["scalars"]>>;
+type PulseRuleShapeCallback<C, K extends keyof C, Ctx extends StandardSchemaV1> = {
+    (ctx: {
+        context: StandardSchemaV1.InferOutput<Ctx>;
+        action: "create" | "update" | "delete";
+        model: K;
+    }): MaybePromise<boolean | PulseRuleShapeStatic<C, K>>;
+};
+type PulseRuleShapeStatic<C, K extends keyof C, Where = PulseWhere<C, K>> = {
+    $select?: {
+        [K in keyof Where]: boolean;
+    };
+    $where?: Where;
+};
+/** </Pulse:Model> */
+/** <Pulse:Any> */
+type AnyPulseRuleShape<Ctx extends StandardSchemaV1> = boolean | AnyPulseRuleShapeStatic | AnyPulseRuleShapeCallback<Ctx>;
+type AnyPulseRuleShapeCallback<Ctx extends StandardSchemaV1> = {
+    (ctx: {
+        context: StandardSchemaV1.InferOutput<Ctx>;
+        action: "create" | "update" | "delete";
+    }): MaybePromise<boolean | AnyPulseRuleShapeStatic>;
+};
+type AnyPulseRuleShapeStatic = {
+    $select?: Record<string, boolean>;
+    $where?: object;
+};
+/** </Pulse:Any> */
+/** </Pulse> */
+/** <Operation> */
+type DeleteOperation = "delete" | "deleteMany";
+type UpdateOperation = "update" | "updateMany" | "updateManyAndReturn" | "upsert";
+type CreateOperation = "create" | "upsert" | "createMany" | "createManyAndReturn";
+type ReadOperation = "aggregate" | "count" | "findFirst" | "findFirstOrThrow" | "findMany" | "findUnique" | "findUniqueOrThrow" | "groupBy";
+type Operation = CreateOperation | DeleteOperation | UpdateOperation | ReadOperation;
+/** <Operation:Model> */
+type OpRuleShape<O extends Operation, C, K extends keyof C, Ctx extends StandardSchemaV1> = boolean | OpRuleShapeWhere<O, C, K> | OpRuleShapeCallback<O, C, K, Ctx> | OpRuleShapeVerbose<O, C, K, Ctx>;
+type OpRuleShapeWhere<O extends Operation, C, K extends keyof C> = Prisma$1.Args<C[K], O> extends {
+    where?: infer W;
+} ? {
+    $where: W;
+    $rule?: never;
+} : never;
+type OpCtx<O extends Operation, C, K extends keyof C, Ctx extends StandardSchemaV1> = K extends unknown ? O extends unknown ? {
+    model: K;
+    operation: O;
+    args: CoerceAnyToNever<Prisma$1.Args<C[K], O>>;
+    context: StandardSchemaV1.InferOutput<Ctx>;
+    uuid?: string;
+} : never : never;
+type OpRuleShapeCallback<O extends Operation, C, K extends keyof C, Ctx extends StandardSchemaV1> = {
+    (ctx: OpCtx<O, C, K, Ctx>): MaybePromise<boolean | OpRuleShapeWhere<O, C, K>>;
+};
+type OpRuleShapeBefore<O extends Operation, C, K extends keyof C, Ctx extends StandardSchemaV1> = {
+    (ctx: OpCtx<O, C, K, Ctx>): MaybePromise<void>;
+};
+type OpRuleShapeAfter<O extends Operation, C, K extends keyof C, Ctx extends StandardSchemaV1> = {
+    (ctx: OpCtx<O, C, K, Ctx> & {
+        result: unknown;
+    }): MaybePromise<void>;
+};
+type OpRuleShapeVerbose<O extends Operation, C, K extends keyof C, Ctx extends StandardSchemaV1> = {
+    $rule: boolean | OpRuleShapeWhere<O, C, K> | OpRuleShapeCallback<O, C, K, Ctx>;
+    $after?: OpRuleShapeAfter<O, C, K, Ctx>;
+    $before?: OpRuleShapeBefore<O, C, K, Ctx>;
+    $blockedFields?: FieldsOf<O, C, K>[];
+    $where?: never;
+};
+/** </Operation:Model> */
+/** <Operation:Any> */
+type AnyOpRuleShape<O extends Operation, Ctx extends StandardSchemaV1> = boolean | AnyOpRuleShapeCallback<O, Ctx> | AnyOpRuleShapeVerbose<O, Ctx>;
+type AnyOpRuleShapeWhere = object;
+type AnyOpCtx<O extends Operation, Ctx extends StandardSchemaV1> = {
+    model: string;
+    operation: O;
+    args: object;
+    context: StandardSchemaV1.InferOutput<Ctx>;
+    uuid?: string;
+};
+type AnyOpRuleShapeCallback<O extends Operation, Ctx extends StandardSchemaV1> = {
+    (ctx: AnyOpCtx<O, Ctx>): MaybePromise<boolean | AnyOpRuleShapeWhere>;
+};
+type AnyOpRuleShapeBefore<O extends Operation, Ctx extends StandardSchemaV1> = {
+    (ctx: AnyOpCtx<O, Ctx>): MaybePromise<void>;
+};
+type AnyOpRuleShapeAfter<O extends Operation, Ctx extends StandardSchemaV1> = {
+    (ctx: AnyOpCtx<O, Ctx> & {
+        result: unknown;
+    }): MaybePromise<void>;
+};
+type AnyOpRuleShapeVerbose<O extends Operation, Ctx extends StandardSchemaV1> = {
+    $rule: boolean | AnyOpRuleShapeCallback<O, Ctx>;
+    $after?: AnyOpRuleShapeAfter<O, Ctx>;
+    $before?: AnyOpRuleShapeBefore<O, Ctx>;
+    $blockedFields?: string[];
+};
+/** </Operation:Any> */
+/** </Operation> */
+type MaybePromise<T> = T | Promise<T>;
+type FieldsOf<O extends Operation, C, K extends keyof C, P extends Record<string, unknown> = Prisma$1.Payload<C[K], O>> = CoerceNeverToValue<keyof P["scalars"] | keyof P["objects"] | keyof P["composites"], string>;
+declare function withPolicy<C, const R extends Rules<C, CtxSchema>, CtxSchema extends StandardSchemaV1 = StandardSchemaV1>(args: {
+    contextSchema?: CtxSchema;
+    rules: R;
+}): (prisma: C) => _prisma_client_extension.PrismaClientExtends<_prisma_client_runtime_library.InternalArgs<{}, {
+    $allModels: {
+        subscribe<TModel, TArgs>(this: TModel, args?: Prisma$1.Exact<TArgs, _prisma_extension_pulse_workerd.PulseSubscribeArgs<TModel>>): Promise<_prisma_extension_pulse_workerd.PulseSubscription<_prisma_extension_pulse_workerd.PulseResultType<_prisma_extension_pulse_workerd.Omit<TArgs, "name">, Prisma$1.Result<TModel, TArgs, "findFirstOrThrow">>>>;
+        stream<TModel_1, TArgs_1>(this: TModel_1, args?: Prisma$1.Exact<TArgs_1, _prisma_extension_pulse_workerd.PulseStreamArgs<TModel_1>>): Promise<_prisma_extension_pulse_workerd.PulseSubscription<_prisma_extension_pulse_workerd.PulseResultType<_prisma_extension_pulse_workerd.Omit<TArgs_1, "name">, Prisma$1.Result<TModel_1, TArgs_1, "findFirstOrThrow">>>>;
+    };
+}, {}, {}> & _prisma_client_runtime_library.DefaultArgs & _prisma_client_runtime_library.InternalArgs<{}, {
+    $allModels: {
+        aggregate<T, A>(this: T, args: _prisma_client_runtime_library.Exact<A, _prisma_client_runtime_library.Args_3<T, "aggregate"> & PrismaCacheStrategy>): AcceleratePromise<_prisma_client_runtime_library.Result_2<T, A, "aggregate">>;
+        count<T_1, A_1>(this: T_1, args?: _prisma_client_runtime_library.Exact<A_1, _prisma_client_runtime_library.Args_3<T_1, "count"> & PrismaCacheStrategy> | undefined): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_1, A_1, "count">>;
+        findFirst<T_2, A_2>(this: T_2, args?: _prisma_client_runtime_library.Exact<A_2, _prisma_client_runtime_library.Args_3<T_2, "findFirst"> & PrismaCacheStrategy> | undefined): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_2, A_2, "findFirst"> | null>;
+        findFirstOrThrow<T_3, A_3>(this: T_3, args?: _prisma_client_runtime_library.Exact<A_3, _prisma_client_runtime_library.Args_3<T_3, "findFirstOrThrow"> & PrismaCacheStrategy> | undefined): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_3, A_3, "findFirstOrThrow">>;
+        findMany<T_4, A_4>(this: T_4, args?: _prisma_client_runtime_library.Exact<A_4, _prisma_client_runtime_library.Args_3<T_4, "findMany"> & PrismaCacheStrategy> | undefined): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_4, A_4, "findMany">>;
+        findUnique<T_5, A_5>(this: T_5, args: _prisma_client_runtime_library.Exact<A_5, _prisma_client_runtime_library.Args_3<T_5, "findUnique"> & PrismaCacheStrategy>): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_5, A_5, "findUnique"> | null>;
+        findUniqueOrThrow<T_6, A_6>(this: T_6, args: _prisma_client_runtime_library.Exact<A_6, _prisma_client_runtime_library.Args_3<T_6, "findUniqueOrThrow"> & PrismaCacheStrategy>): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_6, A_6, "findUniqueOrThrow">>;
+        groupBy<T_7, A_7>(this: T_7, args: _prisma_client_runtime_library.Exact<A_7, _prisma_client_runtime_library.Args_3<T_7, "groupBy"> & PrismaCacheStrategy>): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_7, A_7, "groupBy">>;
+    };
+}, {}, {
+    $accelerate: {
+        invalidate: (input: AccelerateInvalidateInput) => Promise<{
+            requestId: string;
+        }>;
+    };
+}> & _prisma_client_runtime_library.InternalArgs<{}, {}, {}, {}> & _prisma_client_runtime_library.InternalArgs<{}, {}, {}, {
+    $policy: {
+        setGlobalContext(ctx: StandardSchemaV1.InferInput<CtxSchema>): void;
+        contextSchema: unknown;
+        rules: R;
+    };
+}>> & {};
+
+/**
+ * Allow only accessing the models on the client object.
+ */
+type KeepObjectsOnly<T> = {
+    [K in keyof T as K extends `$${string}` ? (K extends "$transaction" | "$policy" ? K : never) : K]: T[K];
+};
+type PolicyClient<T> = KeepObjectsOnly<T>;
+declare const PolicyClient: new <T>(args: {
+    url?: string;
+    publicKey: string;
+}) => PolicyClient<T>;
+
+export { PolicyClient, withPolicy };

package/dist/index.d.ts

@@ -0,0 +1,276 @@
+import * as _prisma_client_extension from '@prisma/client/extension';
+import { Prisma as Prisma$1 } from '@prisma/client/extension';
+import { Prisma } from '@prisma/client/scripts/default-index.js';
+import * as _prisma_client_runtime_library from '@prisma/client/runtime/library';
+import * as _prisma_extension_pulse_workerd from '@prisma/extension-pulse/workerd';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+/// <reference lib="dom" />
+
+interface PrismaCacheStrategy {
+    /**
+     * Specifies the caching parameters for Accelerate.
+     *
+     * `cacheStrategy` only applies when used with an Accelerate connection string.
+     */
+    readonly cacheStrategy?: {
+        /**
+         * `swr` is short for Stale-While-Revalidate.
+         *
+         * `swr` defines the number of seconds that Accelerate may serve _stale_ cache data.
+         * _Stale_ data is a cache hit, but the cache will be refreshed in the background by Accelerate.
+         * The Prisma operation will not be blocked while data is refreshed.
+         *
+         * Use `swr` to reduce the latency of accessing the data while still maintaining
+         * a more up-to-date value in the Accelerate cache.
+         * `swr` without `ttl` will not reduce database load since Accelerate will
+         * run the query in the background.
+         *
+         * `swr` can be combined with `ttl`.
+         * `swr` applies **after** `ttl` has expired.
+         * The total number of seconds data will be cached is `ttl + swr`.
+         *
+         * `swr` only applies when used with an Accelerate connection string.
+         */
+        readonly swr?: number;
+        /**
+         * `ttl` is short for Time-to-Live.
+         *
+         * `ttl` defines the number of seconds that Accelerate may serve _fresh_ cache data.
+         * _Fresh_ data is a cache hit and will not execute the query against the database.
+         *
+         * Use `ttl` to reduce database load and latency for data that does not
+         * require frequent updates.
+         * `ttl` without `swr` will incur a blocking database query for the first
+         * request after `ttl` expires.
+         *
+         * It's recommended to combine `ttl` and `swr` to maintain low latency while
+         * Accelerate refreshes cached data in the background.
+         * `swr` applies **after** `ttl` has expired.
+         * The total number of seconds data will be cached is `ttl + swr`.
+         *
+         * `ttl` only applies when used with an Accelerate connection string.
+         */
+        readonly ttl?: number;
+        /**
+         * `tags` allow you to attach string values to the query's cache entry
+         * that can later be used to invalidate the cache.
+         *
+         * A tag may only contain alphanumeric characters and underscores.
+         * Each tag may contain a maximum of 64 characters.
+         * A maximum of 5 tags are allowed per query.
+         */
+        readonly tags?: ReadonlyArray<string>;
+    };
+}
+interface AccelerateInfo {
+    /**
+     * The cache status of the response.
+     * * `ttl` indicates a cache hit within the `ttl` duration and no database query was executed
+     * * `swr` indicates a cache hit within the `swr` duration and the data is being refreshed by Accelerate in the background
+     * * `miss` indicates that both `ttl` and `swr` have expired and the database query was executed by the request
+     * * `none` indicates that no cache strategy was specified and the database query was executed by the request
+     */
+    cacheStatus: "ttl" | "swr" | "miss" | "none";
+    /**
+     * The date the response was last refreshed.
+     */
+    lastModified: Date;
+    /**
+     * The datacenter region that received the request.
+     */
+    region: string;
+    /**
+     * Unique identifier of the request. Useful for troubleshooting.
+     */
+    requestId: string;
+    /**
+     * The unique signature of the Prisma operation.
+     */
+    signature: string;
+}
+type AccelerateInvalidateInput = {
+    /** Invalidate cache by tags set in the query `cacheStrategy`. */
+    tags: ReadonlyArray<string>;
+};
+interface AcceleratePromise<T> extends Prisma.PrismaPromise<T> {
+    withAccelerateInfo(): Prisma.PrismaPromise<{
+        data: T;
+        info: AccelerateInfo | null;
+    }>;
+}
+
+type CoerceAnyToNever<T> = unknown extends T ? never : T;
+type CoerceNeverToValue<T, V> = [T] extends [never] ? V : T;
+type ModelKeys<T> = {
+    [K in keyof T]: K extends `$${string}` ? never : K;
+}[keyof T];
+type Rules<C, Ctx extends StandardSchemaV1, AllModelKeys extends ModelKeys<C> = ModelKeys<C>> = {
+    [K in AllModelKeys]?: {
+        pulse?: PulseRuleShape<C, K, Ctx>;
+        read?: OpRuleShape<ReadOperation, C, K, Ctx>;
+        create?: OpRuleShape<CreateOperation, C, K, Ctx>;
+        delete?: OpRuleShape<DeleteOperation, C, K, Ctx>;
+        update?: OpRuleShape<UpdateOperation, C, K, Ctx>;
+        $allOperations?: OpRuleShape<Operation, C, K, Ctx>;
+    } | boolean;
+} & {
+    $transaction?: boolean;
+    $allModels?: {
+        pulse?: AnyPulseRuleShape<Ctx>;
+        read?: AnyOpRuleShape<ReadOperation, Ctx>;
+        create?: AnyOpRuleShape<CreateOperation, Ctx>;
+        delete?: AnyOpRuleShape<DeleteOperation, Ctx>;
+        update?: AnyOpRuleShape<UpdateOperation, Ctx>;
+        $allOperations?: AnyOpRuleShape<Operation, Ctx>;
+    } | boolean;
+};
+/** <Pulse> */
+/** <Pulse:Model> */
+type PulseRuleShape<C, K extends keyof C, Ctx extends StandardSchemaV1> = boolean | PulseRuleShapeStatic<C, K> | PulseRuleShapeCallback<C, K, Ctx>;
+type PulseWhere<C, K extends keyof C> = Partial<Pick<Prisma$1.Args<C[K], "findMany">["where"], keyof Prisma$1.Payload<C[K], "findMany">["scalars"]>>;
+type PulseRuleShapeCallback<C, K extends keyof C, Ctx extends StandardSchemaV1> = {
+    (ctx: {
+        context: StandardSchemaV1.InferOutput<Ctx>;
+        action: "create" | "update" | "delete";
+        model: K;
+    }): MaybePromise<boolean | PulseRuleShapeStatic<C, K>>;
+};
+type PulseRuleShapeStatic<C, K extends keyof C, Where = PulseWhere<C, K>> = {
+    $select?: {
+        [K in keyof Where]: boolean;
+    };
+    $where?: Where;
+};
+/** </Pulse:Model> */
+/** <Pulse:Any> */
+type AnyPulseRuleShape<Ctx extends StandardSchemaV1> = boolean | AnyPulseRuleShapeStatic | AnyPulseRuleShapeCallback<Ctx>;
+type AnyPulseRuleShapeCallback<Ctx extends StandardSchemaV1> = {
+    (ctx: {
+        context: StandardSchemaV1.InferOutput<Ctx>;
+        action: "create" | "update" | "delete";
+    }): MaybePromise<boolean | AnyPulseRuleShapeStatic>;
+};
+type AnyPulseRuleShapeStatic = {
+    $select?: Record<string, boolean>;
+    $where?: object;
+};
+/** </Pulse:Any> */
+/** </Pulse> */
+/** <Operation> */
+type DeleteOperation = "delete" | "deleteMany";
+type UpdateOperation = "update" | "updateMany" | "updateManyAndReturn" | "upsert";
+type CreateOperation = "create" | "upsert" | "createMany" | "createManyAndReturn";
+type ReadOperation = "aggregate" | "count" | "findFirst" | "findFirstOrThrow" | "findMany" | "findUnique" | "findUniqueOrThrow" | "groupBy";
+type Operation = CreateOperation | DeleteOperation | UpdateOperation | ReadOperation;
+/** <Operation:Model> */
+type OpRuleShape<O extends Operation, C, K extends keyof C, Ctx extends StandardSchemaV1> = boolean | OpRuleShapeWhere<O, C, K> | OpRuleShapeCallback<O, C, K, Ctx> | OpRuleShapeVerbose<O, C, K, Ctx>;
+type OpRuleShapeWhere<O extends Operation, C, K extends keyof C> = Prisma$1.Args<C[K], O> extends {
+    where?: infer W;
+} ? {
+    $where: W;
+    $rule?: never;
+} : never;
+type OpCtx<O extends Operation, C, K extends keyof C, Ctx extends StandardSchemaV1> = K extends unknown ? O extends unknown ? {
+    model: K;
+    operation: O;
+    args: CoerceAnyToNever<Prisma$1.Args<C[K], O>>;
+    context: StandardSchemaV1.InferOutput<Ctx>;
+    uuid?: string;
+} : never : never;
+type OpRuleShapeCallback<O extends Operation, C, K extends keyof C, Ctx extends StandardSchemaV1> = {
+    (ctx: OpCtx<O, C, K, Ctx>): MaybePromise<boolean | OpRuleShapeWhere<O, C, K>>;
+};
+type OpRuleShapeBefore<O extends Operation, C, K extends keyof C, Ctx extends StandardSchemaV1> = {
+    (ctx: OpCtx<O, C, K, Ctx>): MaybePromise<void>;
+};
+type OpRuleShapeAfter<O extends Operation, C, K extends keyof C, Ctx extends StandardSchemaV1> = {
+    (ctx: OpCtx<O, C, K, Ctx> & {
+        result: unknown;
+    }): MaybePromise<void>;
+};
+type OpRuleShapeVerbose<O extends Operation, C, K extends keyof C, Ctx extends StandardSchemaV1> = {
+    $rule: boolean | OpRuleShapeWhere<O, C, K> | OpRuleShapeCallback<O, C, K, Ctx>;
+    $after?: OpRuleShapeAfter<O, C, K, Ctx>;
+    $before?: OpRuleShapeBefore<O, C, K, Ctx>;
+    $blockedFields?: FieldsOf<O, C, K>[];
+    $where?: never;
+};
+/** </Operation:Model> */
+/** <Operation:Any> */
+type AnyOpRuleShape<O extends Operation, Ctx extends StandardSchemaV1> = boolean | AnyOpRuleShapeCallback<O, Ctx> | AnyOpRuleShapeVerbose<O, Ctx>;
+type AnyOpRuleShapeWhere = object;
+type AnyOpCtx<O extends Operation, Ctx extends StandardSchemaV1> = {
+    model: string;
+    operation: O;
+    args: object;
+    context: StandardSchemaV1.InferOutput<Ctx>;
+    uuid?: string;
+};
+type AnyOpRuleShapeCallback<O extends Operation, Ctx extends StandardSchemaV1> = {
+    (ctx: AnyOpCtx<O, Ctx>): MaybePromise<boolean | AnyOpRuleShapeWhere>;
+};
+type AnyOpRuleShapeBefore<O extends Operation, Ctx extends StandardSchemaV1> = {
+    (ctx: AnyOpCtx<O, Ctx>): MaybePromise<void>;
+};
+type AnyOpRuleShapeAfter<O extends Operation, Ctx extends StandardSchemaV1> = {
+    (ctx: AnyOpCtx<O, Ctx> & {
+        result: unknown;
+    }): MaybePromise<void>;
+};
+type AnyOpRuleShapeVerbose<O extends Operation, Ctx extends StandardSchemaV1> = {
+    $rule: boolean | AnyOpRuleShapeCallback<O, Ctx>;
+    $after?: AnyOpRuleShapeAfter<O, Ctx>;
+    $before?: AnyOpRuleShapeBefore<O, Ctx>;
+    $blockedFields?: string[];
+};
+/** </Operation:Any> */
+/** </Operation> */
+type MaybePromise<T> = T | Promise<T>;
+type FieldsOf<O extends Operation, C, K extends keyof C, P extends Record<string, unknown> = Prisma$1.Payload<C[K], O>> = CoerceNeverToValue<keyof P["scalars"] | keyof P["objects"] | keyof P["composites"], string>;
+declare function withPolicy<C, const R extends Rules<C, CtxSchema>, CtxSchema extends StandardSchemaV1 = StandardSchemaV1>(args: {
+    contextSchema?: CtxSchema;
+    rules: R;
+}): (prisma: C) => _prisma_client_extension.PrismaClientExtends<_prisma_client_runtime_library.InternalArgs<{}, {
+    $allModels: {
+        subscribe<TModel, TArgs>(this: TModel, args?: Prisma$1.Exact<TArgs, _prisma_extension_pulse_workerd.PulseSubscribeArgs<TModel>>): Promise<_prisma_extension_pulse_workerd.PulseSubscription<_prisma_extension_pulse_workerd.PulseResultType<_prisma_extension_pulse_workerd.Omit<TArgs, "name">, Prisma$1.Result<TModel, TArgs, "findFirstOrThrow">>>>;
+        stream<TModel_1, TArgs_1>(this: TModel_1, args?: Prisma$1.Exact<TArgs_1, _prisma_extension_pulse_workerd.PulseStreamArgs<TModel_1>>): Promise<_prisma_extension_pulse_workerd.PulseSubscription<_prisma_extension_pulse_workerd.PulseResultType<_prisma_extension_pulse_workerd.Omit<TArgs_1, "name">, Prisma$1.Result<TModel_1, TArgs_1, "findFirstOrThrow">>>>;
+    };
+}, {}, {}> & _prisma_client_runtime_library.DefaultArgs & _prisma_client_runtime_library.InternalArgs<{}, {
+    $allModels: {
+        aggregate<T, A>(this: T, args: _prisma_client_runtime_library.Exact<A, _prisma_client_runtime_library.Args_3<T, "aggregate"> & PrismaCacheStrategy>): AcceleratePromise<_prisma_client_runtime_library.Result_2<T, A, "aggregate">>;
+        count<T_1, A_1>(this: T_1, args?: _prisma_client_runtime_library.Exact<A_1, _prisma_client_runtime_library.Args_3<T_1, "count"> & PrismaCacheStrategy> | undefined): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_1, A_1, "count">>;
+        findFirst<T_2, A_2>(this: T_2, args?: _prisma_client_runtime_library.Exact<A_2, _prisma_client_runtime_library.Args_3<T_2, "findFirst"> & PrismaCacheStrategy> | undefined): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_2, A_2, "findFirst"> | null>;
+        findFirstOrThrow<T_3, A_3>(this: T_3, args?: _prisma_client_runtime_library.Exact<A_3, _prisma_client_runtime_library.Args_3<T_3, "findFirstOrThrow"> & PrismaCacheStrategy> | undefined): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_3, A_3, "findFirstOrThrow">>;
+        findMany<T_4, A_4>(this: T_4, args?: _prisma_client_runtime_library.Exact<A_4, _prisma_client_runtime_library.Args_3<T_4, "findMany"> & PrismaCacheStrategy> | undefined): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_4, A_4, "findMany">>;
+        findUnique<T_5, A_5>(this: T_5, args: _prisma_client_runtime_library.Exact<A_5, _prisma_client_runtime_library.Args_3<T_5, "findUnique"> & PrismaCacheStrategy>): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_5, A_5, "findUnique"> | null>;
+        findUniqueOrThrow<T_6, A_6>(this: T_6, args: _prisma_client_runtime_library.Exact<A_6, _prisma_client_runtime_library.Args_3<T_6, "findUniqueOrThrow"> & PrismaCacheStrategy>): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_6, A_6, "findUniqueOrThrow">>;
+        groupBy<T_7, A_7>(this: T_7, args: _prisma_client_runtime_library.Exact<A_7, _prisma_client_runtime_library.Args_3<T_7, "groupBy"> & PrismaCacheStrategy>): AcceleratePromise<_prisma_client_runtime_library.Result_2<T_7, A_7, "groupBy">>;
+    };
+}, {}, {
+    $accelerate: {
+        invalidate: (input: AccelerateInvalidateInput) => Promise<{
+            requestId: string;
+        }>;
+    };
+}> & _prisma_client_runtime_library.InternalArgs<{}, {}, {}, {}> & _prisma_client_runtime_library.InternalArgs<{}, {}, {}, {
+    $policy: {
+        setGlobalContext(ctx: StandardSchemaV1.InferInput<CtxSchema>): void;
+        contextSchema: unknown;
+        rules: R;
+    };
+}>> & {};
+
+/**
+ * Allow only accessing the models on the client object.
+ */
+type KeepObjectsOnly<T> = {
+    [K in keyof T as K extends `$${string}` ? (K extends "$transaction" | "$policy" ? K : never) : K]: T[K];
+};
+type PolicyClient<T> = KeepObjectsOnly<T>;
+declare const PolicyClient: new <T>(args: {
+    url?: string;
+    publicKey: string;
+}) => PolicyClient<T>;
+
+export { PolicyClient, withPolicy };