@apibara/protocol 2.1.0-beta.23 → 2.1.0-beta.25

package/dist/codec.cjs

@@ -0,0 +1,241 @@
+'use strict';
+
+function MessageCodec(schema) {
+  return {
+    encode(app) {
+      return new Proxy(app, {
+        get(target, property) {
+          if (!Object.hasOwn(target, property)) {
+            return Reflect.get(target, property);
+          }
+          const v = Reflect.get(target, property);
+          return schema[property].encode(v);
+        }
+      });
+    },
+    decode(proto) {
+      return new Proxy(proto, {
+        get(target, property) {
+          if (!Object.hasOwn(target, property)) {
+            return Reflect.get(target, property);
+          }
+          const v = Reflect.get(target, property);
+          return schema[property].decode(v);
+        }
+      });
+    }
+  };
+}
+function ArrayCodec(t) {
+  return {
+    encode(app) {
+      return app.map(t.encode);
+    },
+    decode(proto) {
+      if (proto === void 0)
+        return [];
+      return proto.map(t.decode);
+    }
+  };
+}
+function MutableArrayCodec(t) {
+  return {
+    encode(app) {
+      return app.map(t.encode);
+    },
+    decode(proto) {
+      if (proto === void 0)
+        return [];
+      return proto.map(t.decode);
+    }
+  };
+}
+function OptionalCodec(t) {
+  return {
+    encode(app) {
+      if (app === void 0)
+        return void 0;
+      return t.encode(app);
+    },
+    decode(proto) {
+      if (proto === void 0)
+        return void 0;
+      return t.decode(proto);
+    }
+  };
+}
+function RequiredCodec(t) {
+  return {
+    encode(app) {
+      if (app === void 0)
+        throw new Error("Value is required but undefined");
+      return t.encode(app);
+    },
+    decode(proto) {
+      if (proto === void 0)
+        throw new Error("Value is required but undefined");
+      return t.decode(proto);
+    }
+  };
+}
+function NullOrCodec(t) {
+  return {
+    encode(app) {
+      if (app === null)
+        return null;
+      return t.encode(app);
+    },
+    decode(proto) {
+      if (proto === null)
+        return null;
+      return t.decode(proto);
+    }
+  };
+}
+const BigIntCodec = {
+  encode(app) {
+    return app;
+  },
+  decode(proto) {
+    return proto;
+  }
+};
+const NumberCodec = {
+  encode(app) {
+    return app;
+  },
+  decode(proto) {
+    return proto;
+  }
+};
+const Uint8ArrayCodec = {
+  encode(app) {
+    return app;
+  },
+  decode(proto) {
+    return proto;
+  }
+};
+const DateCodec = {
+  encode(app) {
+    return new Date(app);
+  },
+  decode(proto) {
+    return new Date(proto);
+  }
+};
+const BooleanCodec = {
+  encode(app) {
+    return app;
+  },
+  decode(proto) {
+    return proto;
+  }
+};
+const StringCodec = {
+  encode(app) {
+    return app;
+  },
+  decode(proto) {
+    return proto;
+  }
+};
+const UndefinedCodec = {
+  encode(app) {
+    return void 0;
+  },
+  decode(proto) {
+    return void 0;
+  }
+};
+const LiteralCodec = (value) => {
+  return {
+    encode(app) {
+      if (app !== value) {
+        throw new Error(`Expected ${String(value)}, got ${String(app)}`);
+      }
+      return app;
+    },
+    decode(proto) {
+      if (proto !== value) {
+        throw new Error(`Expected ${String(value)}, got ${String(proto)}`);
+      }
+      return proto;
+    }
+  };
+};
+const LiteralUnionCodec = (values) => {
+  return {
+    encode(app) {
+      if (!values.includes(app)) {
+        throw new Error(
+          `Expected one of [${values.join(", ")}], got ${String(app)}`
+        );
+      }
+      return app;
+    },
+    decode(proto) {
+      if (!values.includes(proto)) {
+        throw new Error(
+          `Expected one of [${values.join(", ")}], got ${String(proto)}`
+        );
+      }
+      return proto;
+    }
+  };
+};
+const VariantCodec = (options) => {
+  return {
+    encode(app) {
+      const tag = app[options.tag];
+      const codec = options.variants[tag];
+      if (!codec) {
+        throw new Error(`Unknown variant: ${String(tag)}`);
+      }
+      const variantData = app[tag];
+      const encodedData = codec.encode(variantData);
+      return {
+        [options.discriminator]: tag,
+        [tag]: encodedData
+      };
+    },
+    decode(proto) {
+      const tag = proto[options.discriminator];
+      const codec = options.variants[tag];
+      if (!codec) {
+        throw new Error(`Unknown variant: ${String(tag)}`);
+      }
+      const variantData = proto[tag];
+      const decodedData = codec.decode(variantData);
+      return {
+        [options.tag]: tag,
+        [tag]: decodedData
+      };
+    }
+  };
+};
+function OneOfCodec(variants) {
+  return VariantCodec({
+    tag: "_tag",
+    discriminator: "$case",
+    variants
+  });
+}
+
+exports.ArrayCodec = ArrayCodec;
+exports.BigIntCodec = BigIntCodec;
+exports.BooleanCodec = BooleanCodec;
+exports.DateCodec = DateCodec;
+exports.LiteralCodec = LiteralCodec;
+exports.LiteralUnionCodec = LiteralUnionCodec;
+exports.MessageCodec = MessageCodec;
+exports.MutableArrayCodec = MutableArrayCodec;
+exports.NullOrCodec = NullOrCodec;
+exports.NumberCodec = NumberCodec;
+exports.OneOfCodec = OneOfCodec;
+exports.OptionalCodec = OptionalCodec;
+exports.RequiredCodec = RequiredCodec;
+exports.StringCodec = StringCodec;
+exports.Uint8ArrayCodec = Uint8ArrayCodec;
+exports.UndefinedCodec = UndefinedCodec;
+exports.VariantCodec = VariantCodec;

package/dist/codec.d.cts

@@ -0,0 +1,81 @@
+/** Codec to encode and decode protobuf messages */
+type Codec<TApp = unknown, TProto = unknown> = {
+    encode(app: TApp): TProto;
+    decode(proto: TProto): TApp;
+};
+type CodecType<C extends Codec> = ReturnType<C["decode"]>;
+type CodecProto<C extends Codec> = ReturnType<C["encode"]>;
+type Evaluate<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type TPropertyKey = string | symbol;
+type TProperties = Record<TPropertyKey, Codec>;
+type OptionalPropertyKeys<T> = {
+    [K in keyof T]: undefined extends T[K] ? K : never;
+}[keyof T];
+type RequiredPropertyKeys<T> = keyof Omit<T, OptionalPropertyKeys<T>>;
+type _MessageCodecType<T extends TProperties> = {
+    [K in keyof T]: CodecType<T[K]>;
+};
+type _MessageCodecProto<T extends TProperties> = {
+    [K in keyof T]: CodecProto<T[K]>;
+};
+type MessageCodecType<T extends TProperties> = _MessageCodecType<T> extends infer R ? Evaluate<Partial<R> & Required<Pick<R, RequiredPropertyKeys<R>>>> : never;
+type MessageCodecProto<T extends TProperties> = _MessageCodecProto<T> extends infer R ? Evaluate<Partial<R> & Required<Pick<R, RequiredPropertyKeys<R>>>> : never;
+type MessageCodec<T extends TProperties = TProperties> = Codec<MessageCodecType<T>, MessageCodecProto<T>>;
+declare function MessageCodec<T extends TProperties>(schema: T): MessageCodec<T>;
+type ArrayCodec<T extends Codec> = T extends Codec<infer TApp, infer TProto> ? Codec<readonly TApp[], readonly TProto[] | undefined> : never;
+declare function ArrayCodec<T extends Codec<TApp, TProto>, TApp, TProto>(t: T): ArrayCodec<T>;
+type MutableArrayCodec<T extends Codec<TApp, TProto>, TApp, TProto> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp[], TProto[]> : never;
+declare function MutableArrayCodec<T extends Codec<TApp, TProto>, TApp, TProto>(t: T): MutableArrayCodec<T, TApp, TProto>;
+type OptionalCodec<T extends Codec> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp | undefined, TProto | undefined> : never;
+declare function OptionalCodec<T extends Codec>(t: T): OptionalCodec<T>;
+type RequiredCodec<T extends Codec> = T extends Codec<infer TApp, infer TProto> ? TApp extends undefined ? never : Codec<TApp, TProto | undefined> : never;
+declare function RequiredCodec<T extends Codec>(t: T): RequiredCodec<T>;
+type NullOrCodec<T extends Codec> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp | null, TProto | null> : never;
+declare function NullOrCodec<T extends Codec>(t: T): NullOrCodec<T>;
+type BigIntCodec = CodecType<typeof BigIntCodec>;
+declare const BigIntCodec: Codec<bigint, bigint>;
+type NumberCodec = CodecType<typeof NumberCodec>;
+declare const NumberCodec: Codec<number, number>;
+type Uint8ArrayCodec = CodecType<typeof Uint8ArrayCodec>;
+declare const Uint8ArrayCodec: Codec<Uint8Array, Uint8Array>;
+type DateCodec = CodecType<typeof DateCodec>;
+declare const DateCodec: Codec<Date, Date>;
+type BooleanCodec = CodecType<typeof BooleanCodec>;
+declare const BooleanCodec: Codec<boolean, boolean>;
+type StringCodec = CodecType<typeof StringCodec>;
+declare const StringCodec: Codec<string, string>;
+type UndefinedCodec = CodecType<typeof UndefinedCodec>;
+declare const UndefinedCodec: Codec<undefined, undefined>;
+type Literal = string | number | boolean | null | undefined;
+type LiteralCodec<T extends Codec, L extends Literal> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp, TProto> : never;
+declare const LiteralCodec: <const L extends Literal>(value: L) => LiteralCodec<Codec<L, L>, L>;
+type LiteralUnionCodec<T extends Codec, L extends readonly Literal[]> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp, TProto> : never;
+declare const LiteralUnionCodec: <const L extends readonly Literal[]>(values: L) => LiteralUnionCodec<Codec<L[number], L[number]>, L>;
+type AppVariantMap<TTag extends TPropertyKey, TVariants extends TProperties> = {
+    [K in keyof TVariants]: {
+        [P in TTag]: K;
+    } & (CodecType<TVariants[K]> extends UndefinedCodec ? {} : {
+        [P in K & TPropertyKey]: CodecType<TVariants[K]>;
+    });
+};
+type VariantCodecType<TTag extends TPropertyKey, TVariants extends TProperties> = AppVariantMap<TTag, TVariants>[keyof TVariants];
+type ProtoVariantMap<TDiscriminator extends TPropertyKey, TVariants extends TProperties> = {
+    [K in keyof TVariants]: {
+        [P in TDiscriminator]: K;
+    } & {
+        [P in K & TPropertyKey]: CodecProto<TVariants[K]>;
+    };
+};
+type VariantCodecProto<TDiscriminator extends TPropertyKey, TVariants extends TProperties> = ProtoVariantMap<TDiscriminator, TVariants>[keyof TVariants];
+type VariantCodec<T extends Codec, TTag extends TPropertyKey, TDiscriminator extends TPropertyKey> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp, TProto> : never;
+declare const VariantCodec: <TTag extends TPropertyKey, TDiscriminator extends TPropertyKey, TVariants extends TProperties, TCodec extends Codec<VariantCodecType<TTag, TVariants>, VariantCodecProto<TDiscriminator, TVariants>>>(options: {
+    tag: TTag;
+    discriminator: TDiscriminator;
+    variants: TVariants;
+}) => VariantCodec<TCodec, TTag, TDiscriminator>;
+type OneOfCodec<TVariants extends TProperties> = VariantCodec<Codec<VariantCodecType<"_tag", TVariants>, VariantCodecProto<"$case", TVariants>>, "_tag", "$case">;
+declare function OneOfCodec<TVariants extends TProperties>(variants: TVariants): OneOfCodec<TVariants>;
+
+export { ArrayCodec, BigIntCodec, BooleanCodec, type Codec, type CodecProto, type CodecType, DateCodec, type Evaluate, LiteralCodec, LiteralUnionCodec, MessageCodec, MutableArrayCodec, NullOrCodec, NumberCodec, OneOfCodec, OptionalCodec, RequiredCodec, StringCodec, Uint8ArrayCodec, UndefinedCodec, VariantCodec };

package/dist/codec.d.mts

@@ -0,0 +1,81 @@
+/** Codec to encode and decode protobuf messages */
+type Codec<TApp = unknown, TProto = unknown> = {
+    encode(app: TApp): TProto;
+    decode(proto: TProto): TApp;
+};
+type CodecType<C extends Codec> = ReturnType<C["decode"]>;
+type CodecProto<C extends Codec> = ReturnType<C["encode"]>;
+type Evaluate<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type TPropertyKey = string | symbol;
+type TProperties = Record<TPropertyKey, Codec>;
+type OptionalPropertyKeys<T> = {
+    [K in keyof T]: undefined extends T[K] ? K : never;
+}[keyof T];
+type RequiredPropertyKeys<T> = keyof Omit<T, OptionalPropertyKeys<T>>;
+type _MessageCodecType<T extends TProperties> = {
+    [K in keyof T]: CodecType<T[K]>;
+};
+type _MessageCodecProto<T extends TProperties> = {
+    [K in keyof T]: CodecProto<T[K]>;
+};
+type MessageCodecType<T extends TProperties> = _MessageCodecType<T> extends infer R ? Evaluate<Partial<R> & Required<Pick<R, RequiredPropertyKeys<R>>>> : never;
+type MessageCodecProto<T extends TProperties> = _MessageCodecProto<T> extends infer R ? Evaluate<Partial<R> & Required<Pick<R, RequiredPropertyKeys<R>>>> : never;
+type MessageCodec<T extends TProperties = TProperties> = Codec<MessageCodecType<T>, MessageCodecProto<T>>;
+declare function MessageCodec<T extends TProperties>(schema: T): MessageCodec<T>;
+type ArrayCodec<T extends Codec> = T extends Codec<infer TApp, infer TProto> ? Codec<readonly TApp[], readonly TProto[] | undefined> : never;
+declare function ArrayCodec<T extends Codec<TApp, TProto>, TApp, TProto>(t: T): ArrayCodec<T>;
+type MutableArrayCodec<T extends Codec<TApp, TProto>, TApp, TProto> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp[], TProto[]> : never;
+declare function MutableArrayCodec<T extends Codec<TApp, TProto>, TApp, TProto>(t: T): MutableArrayCodec<T, TApp, TProto>;
+type OptionalCodec<T extends Codec> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp | undefined, TProto | undefined> : never;
+declare function OptionalCodec<T extends Codec>(t: T): OptionalCodec<T>;
+type RequiredCodec<T extends Codec> = T extends Codec<infer TApp, infer TProto> ? TApp extends undefined ? never : Codec<TApp, TProto | undefined> : never;
+declare function RequiredCodec<T extends Codec>(t: T): RequiredCodec<T>;
+type NullOrCodec<T extends Codec> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp | null, TProto | null> : never;
+declare function NullOrCodec<T extends Codec>(t: T): NullOrCodec<T>;
+type BigIntCodec = CodecType<typeof BigIntCodec>;
+declare const BigIntCodec: Codec<bigint, bigint>;
+type NumberCodec = CodecType<typeof NumberCodec>;
+declare const NumberCodec: Codec<number, number>;
+type Uint8ArrayCodec = CodecType<typeof Uint8ArrayCodec>;
+declare const Uint8ArrayCodec: Codec<Uint8Array, Uint8Array>;
+type DateCodec = CodecType<typeof DateCodec>;
+declare const DateCodec: Codec<Date, Date>;
+type BooleanCodec = CodecType<typeof BooleanCodec>;
+declare const BooleanCodec: Codec<boolean, boolean>;
+type StringCodec = CodecType<typeof StringCodec>;
+declare const StringCodec: Codec<string, string>;
+type UndefinedCodec = CodecType<typeof UndefinedCodec>;
+declare const UndefinedCodec: Codec<undefined, undefined>;
+type Literal = string | number | boolean | null | undefined;
+type LiteralCodec<T extends Codec, L extends Literal> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp, TProto> : never;
+declare const LiteralCodec: <const L extends Literal>(value: L) => LiteralCodec<Codec<L, L>, L>;
+type LiteralUnionCodec<T extends Codec, L extends readonly Literal[]> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp, TProto> : never;
+declare const LiteralUnionCodec: <const L extends readonly Literal[]>(values: L) => LiteralUnionCodec<Codec<L[number], L[number]>, L>;
+type AppVariantMap<TTag extends TPropertyKey, TVariants extends TProperties> = {
+    [K in keyof TVariants]: {
+        [P in TTag]: K;
+    } & (CodecType<TVariants[K]> extends UndefinedCodec ? {} : {
+        [P in K & TPropertyKey]: CodecType<TVariants[K]>;
+    });
+};
+type VariantCodecType<TTag extends TPropertyKey, TVariants extends TProperties> = AppVariantMap<TTag, TVariants>[keyof TVariants];
+type ProtoVariantMap<TDiscriminator extends TPropertyKey, TVariants extends TProperties> = {
+    [K in keyof TVariants]: {
+        [P in TDiscriminator]: K;
+    } & {
+        [P in K & TPropertyKey]: CodecProto<TVariants[K]>;
+    };
+};
+type VariantCodecProto<TDiscriminator extends TPropertyKey, TVariants extends TProperties> = ProtoVariantMap<TDiscriminator, TVariants>[keyof TVariants];
+type VariantCodec<T extends Codec, TTag extends TPropertyKey, TDiscriminator extends TPropertyKey> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp, TProto> : never;
+declare const VariantCodec: <TTag extends TPropertyKey, TDiscriminator extends TPropertyKey, TVariants extends TProperties, TCodec extends Codec<VariantCodecType<TTag, TVariants>, VariantCodecProto<TDiscriminator, TVariants>>>(options: {
+    tag: TTag;
+    discriminator: TDiscriminator;
+    variants: TVariants;
+}) => VariantCodec<TCodec, TTag, TDiscriminator>;
+type OneOfCodec<TVariants extends TProperties> = VariantCodec<Codec<VariantCodecType<"_tag", TVariants>, VariantCodecProto<"$case", TVariants>>, "_tag", "$case">;
+declare function OneOfCodec<TVariants extends TProperties>(variants: TVariants): OneOfCodec<TVariants>;
+
+export { ArrayCodec, BigIntCodec, BooleanCodec, type Codec, type CodecProto, type CodecType, DateCodec, type Evaluate, LiteralCodec, LiteralUnionCodec, MessageCodec, MutableArrayCodec, NullOrCodec, NumberCodec, OneOfCodec, OptionalCodec, RequiredCodec, StringCodec, Uint8ArrayCodec, UndefinedCodec, VariantCodec };

package/dist/codec.d.ts

@@ -0,0 +1,81 @@
+/** Codec to encode and decode protobuf messages */
+type Codec<TApp = unknown, TProto = unknown> = {
+    encode(app: TApp): TProto;
+    decode(proto: TProto): TApp;
+};
+type CodecType<C extends Codec> = ReturnType<C["decode"]>;
+type CodecProto<C extends Codec> = ReturnType<C["encode"]>;
+type Evaluate<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type TPropertyKey = string | symbol;
+type TProperties = Record<TPropertyKey, Codec>;
+type OptionalPropertyKeys<T> = {
+    [K in keyof T]: undefined extends T[K] ? K : never;
+}[keyof T];
+type RequiredPropertyKeys<T> = keyof Omit<T, OptionalPropertyKeys<T>>;
+type _MessageCodecType<T extends TProperties> = {
+    [K in keyof T]: CodecType<T[K]>;
+};
+type _MessageCodecProto<T extends TProperties> = {
+    [K in keyof T]: CodecProto<T[K]>;
+};
+type MessageCodecType<T extends TProperties> = _MessageCodecType<T> extends infer R ? Evaluate<Partial<R> & Required<Pick<R, RequiredPropertyKeys<R>>>> : never;
+type MessageCodecProto<T extends TProperties> = _MessageCodecProto<T> extends infer R ? Evaluate<Partial<R> & Required<Pick<R, RequiredPropertyKeys<R>>>> : never;
+type MessageCodec<T extends TProperties = TProperties> = Codec<MessageCodecType<T>, MessageCodecProto<T>>;
+declare function MessageCodec<T extends TProperties>(schema: T): MessageCodec<T>;
+type ArrayCodec<T extends Codec> = T extends Codec<infer TApp, infer TProto> ? Codec<readonly TApp[], readonly TProto[] | undefined> : never;
+declare function ArrayCodec<T extends Codec<TApp, TProto>, TApp, TProto>(t: T): ArrayCodec<T>;
+type MutableArrayCodec<T extends Codec<TApp, TProto>, TApp, TProto> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp[], TProto[]> : never;
+declare function MutableArrayCodec<T extends Codec<TApp, TProto>, TApp, TProto>(t: T): MutableArrayCodec<T, TApp, TProto>;
+type OptionalCodec<T extends Codec> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp | undefined, TProto | undefined> : never;
+declare function OptionalCodec<T extends Codec>(t: T): OptionalCodec<T>;
+type RequiredCodec<T extends Codec> = T extends Codec<infer TApp, infer TProto> ? TApp extends undefined ? never : Codec<TApp, TProto | undefined> : never;
+declare function RequiredCodec<T extends Codec>(t: T): RequiredCodec<T>;
+type NullOrCodec<T extends Codec> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp | null, TProto | null> : never;
+declare function NullOrCodec<T extends Codec>(t: T): NullOrCodec<T>;
+type BigIntCodec = CodecType<typeof BigIntCodec>;
+declare const BigIntCodec: Codec<bigint, bigint>;
+type NumberCodec = CodecType<typeof NumberCodec>;
+declare const NumberCodec: Codec<number, number>;
+type Uint8ArrayCodec = CodecType<typeof Uint8ArrayCodec>;
+declare const Uint8ArrayCodec: Codec<Uint8Array, Uint8Array>;
+type DateCodec = CodecType<typeof DateCodec>;
+declare const DateCodec: Codec<Date, Date>;
+type BooleanCodec = CodecType<typeof BooleanCodec>;
+declare const BooleanCodec: Codec<boolean, boolean>;
+type StringCodec = CodecType<typeof StringCodec>;
+declare const StringCodec: Codec<string, string>;
+type UndefinedCodec = CodecType<typeof UndefinedCodec>;
+declare const UndefinedCodec: Codec<undefined, undefined>;
+type Literal = string | number | boolean | null | undefined;
+type LiteralCodec<T extends Codec, L extends Literal> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp, TProto> : never;
+declare const LiteralCodec: <const L extends Literal>(value: L) => LiteralCodec<Codec<L, L>, L>;
+type LiteralUnionCodec<T extends Codec, L extends readonly Literal[]> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp, TProto> : never;
+declare const LiteralUnionCodec: <const L extends readonly Literal[]>(values: L) => LiteralUnionCodec<Codec<L[number], L[number]>, L>;
+type AppVariantMap<TTag extends TPropertyKey, TVariants extends TProperties> = {
+    [K in keyof TVariants]: {
+        [P in TTag]: K;
+    } & (CodecType<TVariants[K]> extends UndefinedCodec ? {} : {
+        [P in K & TPropertyKey]: CodecType<TVariants[K]>;
+    });
+};
+type VariantCodecType<TTag extends TPropertyKey, TVariants extends TProperties> = AppVariantMap<TTag, TVariants>[keyof TVariants];
+type ProtoVariantMap<TDiscriminator extends TPropertyKey, TVariants extends TProperties> = {
+    [K in keyof TVariants]: {
+        [P in TDiscriminator]: K;
+    } & {
+        [P in K & TPropertyKey]: CodecProto<TVariants[K]>;
+    };
+};
+type VariantCodecProto<TDiscriminator extends TPropertyKey, TVariants extends TProperties> = ProtoVariantMap<TDiscriminator, TVariants>[keyof TVariants];
+type VariantCodec<T extends Codec, TTag extends TPropertyKey, TDiscriminator extends TPropertyKey> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp, TProto> : never;
+declare const VariantCodec: <TTag extends TPropertyKey, TDiscriminator extends TPropertyKey, TVariants extends TProperties, TCodec extends Codec<VariantCodecType<TTag, TVariants>, VariantCodecProto<TDiscriminator, TVariants>>>(options: {
+    tag: TTag;
+    discriminator: TDiscriminator;
+    variants: TVariants;
+}) => VariantCodec<TCodec, TTag, TDiscriminator>;
+type OneOfCodec<TVariants extends TProperties> = VariantCodec<Codec<VariantCodecType<"_tag", TVariants>, VariantCodecProto<"$case", TVariants>>, "_tag", "$case">;
+declare function OneOfCodec<TVariants extends TProperties>(variants: TVariants): OneOfCodec<TVariants>;
+
+export { ArrayCodec, BigIntCodec, BooleanCodec, type Codec, type CodecProto, type CodecType, DateCodec, type Evaluate, LiteralCodec, LiteralUnionCodec, MessageCodec, MutableArrayCodec, NullOrCodec, NumberCodec, OneOfCodec, OptionalCodec, RequiredCodec, StringCodec, Uint8ArrayCodec, UndefinedCodec, VariantCodec };