feat: migrate from Cedar to SpiceDB authorization system

This is a major architectural change that replaces the Cedar policy-based
authorization system with SpiceDB's relation-based authorization.

Key changes:

- Migrate from Rust to Go implementation
- Replace Cedar policies with SpiceDB schema and relationships
- Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks
- Update build system and dependencies for Go ecosystem
- Maintain Envoy integration for external authorization

This change enables more flexible permission modeling through SpiceDB's
Google Zanzibar inspired relation-based system, supporting complex
hierarchical permissions that were difficult to express in Cedar.

Breaking change: Existing Cedar policies and Rust-based configuration
will no longer work and need to be migrated to SpiceDB schema.

6 files changed, 0 insertions, 541 deletions

diff --git a/vendor/enum-ordinalize/.cargo-checksum.json b/vendor/enum-ordinalize/.cargo-checksum.json
deleted file mode 100644
index 81a90b05..00000000
--- a/vendor/enum-ordinalize/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"d2ce450053b23e7c599a79fb3aba2521ea89d1ad0aa98b11d14f5a340cb75446","LICENSE":"dd0741aba702705d02da3e18fca5d3a27538fe6c983e9f09946e82ecfc59acab","README.md":"6162387cbab541723549fda8bc385cc806ad97cc63e845bacf79b9ce6a7e1b19","src/lib.rs":"b514e0a839eb9036cad86a8195031f81af9492963fc003fa6e5c4222d10d04ef","src/traits.rs":"3fabe415457bb06aac14edc78ff407727eff61caf1d680a23f006ad39bf7a7c9"},"package":"fea0dcfa4e54eeb516fe454635a95753ddd39acda650ce703031c6973e315dd5"}
\ No newline at end of file
diff --git a/vendor/enum-ordinalize/Cargo.toml b/vendor/enum-ordinalize/Cargo.toml
deleted file mode 100644
index 42e017d1..00000000
--- a/vendor/enum-ordinalize/Cargo.toml
+++ /dev/null
@@ -1,58 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2021"
-rust-version = "1.60"
-name = "enum-ordinalize"
-version = "4.3.0"
-include = [
-    "src/**/*",
-    "Cargo.toml",
-    "README.md",
-    "LICENSE",
-]
-description = "This library enables enums to not only obtain the ordinal values of their variants but also allows for the construction of enums from an ordinal value."
-homepage = "https://magiclen.org/enum-ordinalize"
-readme = "README.md"
-keywords = [
-    "enum",
-    "ordinal",
-    "ordinalize",
-    "number",
-]
-categories = [
-    "no-std",
-    "rust-patterns",
-]
-license = "MIT"
-repository = "https://github.com/magiclen/enum-ordinalize"
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = [
-    "--cfg",
-    "docsrs",
-]
-
-[dependencies.enum-ordinalize-derive]
-version = "4.3"
-optional = true
-default-features = false
-
-[features]
-default = [
-    "derive",
-    "traits",
-]
-derive = ["dep:enum-ordinalize-derive"]
-nightly-test = []
-traits = ["enum-ordinalize-derive?/traits"]
diff --git a/vendor/enum-ordinalize/LICENSE b/vendor/enum-ordinalize/LICENSE
deleted file mode 100644
index ba1efc6c..00000000
--- a/vendor/enum-ordinalize/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 magiclen.org (Ron Li)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/vendor/enum-ordinalize/README.md b/vendor/enum-ordinalize/README.md
deleted file mode 100644
index 2b4a41bc..00000000
--- a/vendor/enum-ordinalize/README.md
+++ /dev/null
@@ -1,190 +0,0 @@
-Enum Ordinalize
-====================
-
-[![CI](https://github.com/magiclen/enum-ordinalize/actions/workflows/ci.yml/badge.svg)](https://github.com/magiclen/enum-ordinalize/actions/workflows/ci.yml)
-
-This library enables enums to not only obtain the ordinal values of their variants but also allows for the construction of enums from an ordinal value.
-
-## Usage
-
-Use `#[derive(Ordinalize)]` to have an enum (which must only has unit variants) implement the `Ordinalize` trait.
-
-```rust
-use enum_ordinalize::Ordinalize;
-
-#[derive(Debug, PartialEq, Eq, Ordinalize)]
-enum MyEnum {
-    Zero,
-    One,
-    Two,
-}
-
-assert_eq!(3, MyEnum::VARIANT_COUNT);
-assert_eq!([MyEnum::Zero, MyEnum::One, MyEnum::Two], MyEnum::VARIANTS);
-assert_eq!([0i8, 1i8, 2i8], MyEnum::VALUES);
-
-assert_eq!(0i8, MyEnum::Zero.ordinal());
-assert_eq!(1i8, MyEnum::One.ordinal());
-assert_eq!(2i8, MyEnum::Two.ordinal());
-
-assert_eq!(Some(MyEnum::Zero), MyEnum::from_ordinal(0i8));
-assert_eq!(Some(MyEnum::One), MyEnum::from_ordinal(1i8));
-assert_eq!(Some(MyEnum::Two), MyEnum::from_ordinal(2i8));
-
-assert_eq!(MyEnum::Zero, unsafe { MyEnum::from_ordinal_unsafe(0i8) });
-assert_eq!(MyEnum::One, unsafe { MyEnum::from_ordinal_unsafe(1i8) });
-assert_eq!(MyEnum::Two, unsafe { MyEnum::from_ordinal_unsafe(2i8) });
-```
-
-#### The (Ordinal) Size of an Enum
-
-The ordinal value is an integer whose size is determined by the enum itself. The size of the enum increases with the magnitude of the variants' values, whether larger (or smaller if negative).
-
-For example,
-
-```rust
-use enum_ordinalize::Ordinalize;
-
-#[derive(Debug, PartialEq, Eq, Ordinalize)]
-enum MyEnum {
-    Zero,
-    One,
-    Two,
-    Thousand = 1000,
-}
-
-assert_eq!(4, MyEnum::VARIANT_COUNT);
-assert_eq!([MyEnum::Zero, MyEnum::One, MyEnum::Two, MyEnum::Thousand], MyEnum::VARIANTS);
-assert_eq!([0i16, 1i16, 2i16, 1000i16], MyEnum::VALUES);
-
-assert_eq!(0i16, MyEnum::Zero.ordinal());
-assert_eq!(1i16, MyEnum::One.ordinal());
-assert_eq!(2i16, MyEnum::Two.ordinal());
-
-assert_eq!(Some(MyEnum::Zero), MyEnum::from_ordinal(0i16));
-assert_eq!(Some(MyEnum::One), MyEnum::from_ordinal(1i16));
-assert_eq!(Some(MyEnum::Two), MyEnum::from_ordinal(2i16));
-
-assert_eq!(MyEnum::Zero, unsafe { MyEnum::from_ordinal_unsafe(0i16) });
-assert_eq!(MyEnum::One, unsafe { MyEnum::from_ordinal_unsafe(1i16) });
-assert_eq!(MyEnum::Two, unsafe { MyEnum::from_ordinal_unsafe(2i16) });
-```
-
-In order to accommodate the value `1000`, the size of `MyEnum` increases. Consequently, the ordinal is represented in `i16` instead of `i8`.
-
-You can utilize the `#[repr(type)]` attribute to explicitly control the size. For instance,
-
-```rust
-use enum_ordinalize::Ordinalize;
-
-#[derive(Debug, PartialEq, Eq, Ordinalize)]
-#[repr(usize)]
-enum MyEnum {
-    Zero,
-    One,
-    Two,
-    Thousand = 1000,
-}
-
-assert_eq!(4, MyEnum::VARIANT_COUNT);
-assert_eq!([MyEnum::Zero, MyEnum::One, MyEnum::Two, MyEnum::Thousand], MyEnum::VARIANTS);
-assert_eq!([0usize, 1usize, 2usize, 1000usize], MyEnum::VALUES);
-
-assert_eq!(0usize, MyEnum::Zero.ordinal());
-assert_eq!(1usize, MyEnum::One.ordinal());
-assert_eq!(2usize, MyEnum::Two.ordinal());
-
-assert_eq!(Some(MyEnum::Zero), MyEnum::from_ordinal(0usize));
-assert_eq!(Some(MyEnum::One), MyEnum::from_ordinal(1usize));
-assert_eq!(Some(MyEnum::Two), MyEnum::from_ordinal(2usize));
-
-assert_eq!(MyEnum::Zero, unsafe { MyEnum::from_ordinal_unsafe(0usize) });
-assert_eq!(MyEnum::One, unsafe { MyEnum::from_ordinal_unsafe(1usize) });
-assert_eq!(MyEnum::Two, unsafe { MyEnum::from_ordinal_unsafe(2usize) });
-```
-
-#### Useful Increment
-
-The integers represented by variants can be extended in successive increments and set explicitly from any value.
-
-```rust
-use enum_ordinalize::Ordinalize;
-
-#[derive(Debug, PartialEq, Eq, Ordinalize)]
-enum MyEnum {
-    Two   = 2,
-    Three,
-    Four,
-    Eight = 8,
-    Nine,
-    NegativeTen = -10,
-    NegativeNine,
-}
-
-assert_eq!(7, MyEnum::VARIANT_COUNT);
-assert_eq!([MyEnum::Two, MyEnum::Three, MyEnum::Four, MyEnum::Eight, MyEnum::Nine, MyEnum::NegativeTen, MyEnum::NegativeNine], MyEnum::VARIANTS);
-assert_eq!([2i8, 3i8, 4i8, 8i8, 9i8, -10i8, -9i8], MyEnum::VALUES);
-
-assert_eq!(4i8, MyEnum::Four.ordinal());
-assert_eq!(9i8, MyEnum::Nine.ordinal());
-assert_eq!(-9i8, MyEnum::NegativeNine.ordinal());
-
-assert_eq!(Some(MyEnum::Four), MyEnum::from_ordinal(4i8));
-assert_eq!(Some(MyEnum::Nine), MyEnum::from_ordinal(9i8));
-assert_eq!(Some(MyEnum::NegativeNine), MyEnum::from_ordinal(-9i8));
-
-assert_eq!(MyEnum::Four, unsafe { MyEnum::from_ordinal_unsafe(4i8) });
-assert_eq!(MyEnum::Nine, unsafe { MyEnum::from_ordinal_unsafe(9i8) });
-assert_eq!(MyEnum::NegativeNine, unsafe { MyEnum::from_ordinal_unsafe(-9i8) });
-```
-
-#### Implement Functionality for an enum on Itself
-
-For some reason, if you don't want to implement the `Ordinalize` trait for your enum, you can choose to disable the trait implementation and enable the constants/functions one by one. Functions are `const fn`. Names and visibility can also be defined by you.
-
-```rust
-use enum_ordinalize::Ordinalize;
-
-#[derive(Debug, PartialEq, Eq, Ordinalize)]
-#[ordinalize(impl_trait = false)]
-#[ordinalize(variant_count(pub const VARIANT_COUNT, doc = "The count of variants."))]
-#[ordinalize(variants(pub const VARIANTS, doc = "List of this enum's variants."))]
-#[ordinalize(values(pub const VALUES, doc = "List of values for all variants of this enum."))]
-#[ordinalize(ordinal(pub const fn ordinal, doc = "Retrieve the integer number of this variant."))]
-#[ordinalize(from_ordinal(pub const fn from_ordinal, doc = "Obtain a variant based on an integer number."))]
-#[ordinalize(from_ordinal_unsafe(
-    pub const fn from_ordinal_unsafe,
-    doc = "Obtain a variant based on an integer number.",
-    doc = "# Safety",
-    doc = "You have to ensure that the input integer number can correspond to a variant on your own.",
-))]
-enum MyEnum {
-    A,
-    B,
-}
-
-assert_eq!(2, MyEnum::VARIANT_COUNT);
-assert_eq!([MyEnum::A, MyEnum::B], MyEnum::VARIANTS);
-assert_eq!([0i8, 1i8], MyEnum::VALUES);
-
-assert_eq!(0i8, MyEnum::A.ordinal());
-assert_eq!(1i8, MyEnum::B.ordinal());
-
-assert_eq!(Some(MyEnum::A), MyEnum::from_ordinal(0i8));
-assert_eq!(Some(MyEnum::B), MyEnum::from_ordinal(1i8));
-
-assert_eq!(MyEnum::A, unsafe { MyEnum::from_ordinal_unsafe(0i8) });
-assert_eq!(MyEnum::B, unsafe { MyEnum::from_ordinal_unsafe(1i8) });
-```
-
-## Crates.io
-
-https://crates.io/crates/enum-ordinalize
-
-## Documentation
-
-https://docs.rs/enum-ordinalize
-
-## License
-
-[MIT](LICENSE)
\ No newline at end of file
diff --git a/vendor/enum-ordinalize/src/lib.rs b/vendor/enum-ordinalize/src/lib.rs
deleted file mode 100644
index 5601114c..00000000
--- a/vendor/enum-ordinalize/src/lib.rs
+++ /dev/null
@@ -1,203 +0,0 @@
-/*!
-# Enum Ordinalize
-
-This library enables enums to not only obtain the ordinal values of their variants but also allows for the construction of enums from an ordinal value.
-
-## Usage
-
-Use `#[derive(Ordinalize)]` to have an enum (which must only has unit variants) implement the `Ordinalize` trait.
-
-```rust
-# #[cfg(all(feature = "derive", feature = "traits"))]
-# {
-use enum_ordinalize::Ordinalize;
-
-#[derive(Debug, PartialEq, Eq, Ordinalize)]
-enum MyEnum {
-    Zero,
-    One,
-    Two,
-}
-
-assert_eq!(3, MyEnum::VARIANT_COUNT);
-assert_eq!([MyEnum::Zero, MyEnum::One, MyEnum::Two], MyEnum::VARIANTS);
-assert_eq!([0i8, 1i8, 2i8], MyEnum::VALUES);
-
-assert_eq!(0i8, MyEnum::Zero.ordinal());
-assert_eq!(1i8, MyEnum::One.ordinal());
-assert_eq!(2i8, MyEnum::Two.ordinal());
-
-assert_eq!(Some(MyEnum::Zero), MyEnum::from_ordinal(0i8));
-assert_eq!(Some(MyEnum::One), MyEnum::from_ordinal(1i8));
-assert_eq!(Some(MyEnum::Two), MyEnum::from_ordinal(2i8));
-
-assert_eq!(MyEnum::Zero, unsafe { MyEnum::from_ordinal_unsafe(0i8) });
-assert_eq!(MyEnum::One, unsafe { MyEnum::from_ordinal_unsafe(1i8) });
-assert_eq!(MyEnum::Two, unsafe { MyEnum::from_ordinal_unsafe(2i8) });
-# }
-```
-
-#### The (Ordinal) Size of an Enum
-
-The ordinal value is an integer whose size is determined by the enum itself. The size of the enum increases with the magnitude of the variants' values, whether larger (or smaller if negative).
-
-For example,
-
-```rust
-# #[cfg(all(feature = "derive", feature = "traits"))]
-# {
-use enum_ordinalize::Ordinalize;
-
-#[derive(Debug, PartialEq, Eq, Ordinalize)]
-enum MyEnum {
-    Zero,
-    One,
-    Two,
-    Thousand = 1000,
-}
-
-assert_eq!(4, MyEnum::VARIANT_COUNT);
-assert_eq!([MyEnum::Zero, MyEnum::One, MyEnum::Two, MyEnum::Thousand], MyEnum::VARIANTS);
-assert_eq!([0i16, 1i16, 2i16, 1000i16], MyEnum::VALUES);
-
-assert_eq!(0i16, MyEnum::Zero.ordinal());
-assert_eq!(1i16, MyEnum::One.ordinal());
-assert_eq!(2i16, MyEnum::Two.ordinal());
-
-assert_eq!(Some(MyEnum::Zero), MyEnum::from_ordinal(0i16));
-assert_eq!(Some(MyEnum::One), MyEnum::from_ordinal(1i16));
-assert_eq!(Some(MyEnum::Two), MyEnum::from_ordinal(2i16));
-
-assert_eq!(MyEnum::Zero, unsafe { MyEnum::from_ordinal_unsafe(0i16) });
-assert_eq!(MyEnum::One, unsafe { MyEnum::from_ordinal_unsafe(1i16) });
-assert_eq!(MyEnum::Two, unsafe { MyEnum::from_ordinal_unsafe(2i16) });
-# }
-```
-
-In order to accommodate the value `1000`, the size of `MyEnum` increases. Consequently, the ordinal is represented in `i16` instead of `i8`.
-
-You can utilize the `#[repr(type)]` attribute to explicitly control the size. For instance,
-
-```rust
-# #[cfg(all(feature = "derive", feature = "traits"))]
-# {
-use enum_ordinalize::Ordinalize;
-
-#[derive(Debug, PartialEq, Eq, Ordinalize)]
-#[repr(usize)]
-enum MyEnum {
-    Zero,
-    One,
-    Two,
-    Thousand = 1000,
-}
-
-assert_eq!(4, MyEnum::VARIANT_COUNT);
-assert_eq!([MyEnum::Zero, MyEnum::One, MyEnum::Two, MyEnum::Thousand], MyEnum::VARIANTS);
-assert_eq!([0usize, 1usize, 2usize, 1000usize], MyEnum::VALUES);
-
-assert_eq!(0usize, MyEnum::Zero.ordinal());
-assert_eq!(1usize, MyEnum::One.ordinal());
-assert_eq!(2usize, MyEnum::Two.ordinal());
-
-assert_eq!(Some(MyEnum::Zero), MyEnum::from_ordinal(0usize));
-assert_eq!(Some(MyEnum::One), MyEnum::from_ordinal(1usize));
-assert_eq!(Some(MyEnum::Two), MyEnum::from_ordinal(2usize));
-
-assert_eq!(MyEnum::Zero, unsafe { MyEnum::from_ordinal_unsafe(0usize) });
-assert_eq!(MyEnum::One, unsafe { MyEnum::from_ordinal_unsafe(1usize) });
-assert_eq!(MyEnum::Two, unsafe { MyEnum::from_ordinal_unsafe(2usize) });
-# }
-```
-
-#### Useful Increment
-
-The integers represented by variants can be extended in successive increments and set explicitly from any value.
-
-```rust
-# #[cfg(all(feature = "derive", feature = "traits"))]
-# {
-use enum_ordinalize::Ordinalize;
-
-#[derive(Debug, PartialEq, Eq, Ordinalize)]
-enum MyEnum {
-    Two   = 2,
-    Three,
-    Four,
-    Eight = 8,
-    Nine,
-    NegativeTen = -10,
-    NegativeNine,
-}
-
-assert_eq!(7, MyEnum::VARIANT_COUNT);
-assert_eq!([MyEnum::Two, MyEnum::Three, MyEnum::Four, MyEnum::Eight, MyEnum::Nine, MyEnum::NegativeTen, MyEnum::NegativeNine], MyEnum::VARIANTS);
-assert_eq!([2i8, 3i8, 4i8, 8i8, 9i8, -10i8, -9i8], MyEnum::VALUES);
-
-assert_eq!(4i8, MyEnum::Four.ordinal());
-assert_eq!(9i8, MyEnum::Nine.ordinal());
-assert_eq!(-9i8, MyEnum::NegativeNine.ordinal());
-
-assert_eq!(Some(MyEnum::Four), MyEnum::from_ordinal(4i8));
-assert_eq!(Some(MyEnum::Nine), MyEnum::from_ordinal(9i8));
-assert_eq!(Some(MyEnum::NegativeNine), MyEnum::from_ordinal(-9i8));
-
-assert_eq!(MyEnum::Four, unsafe { MyEnum::from_ordinal_unsafe(4i8) });
-assert_eq!(MyEnum::Nine, unsafe { MyEnum::from_ordinal_unsafe(9i8) });
-assert_eq!(MyEnum::NegativeNine, unsafe { MyEnum::from_ordinal_unsafe(-9i8) });
-# }
-```
-
-#### Implement Functionality for an enum on Itself
-
-For some reason, if you don't want to implement the `Ordinalize` trait for your enum, you can choose to disable the trait implementation and enable the constants/functions one by one. Functions are `const fn`. Names and visibility can also be defined by you.
-
-```rust
-# #[cfg(feature = "derive")]
-# {
-use enum_ordinalize::Ordinalize;
-
-#[derive(Debug, PartialEq, Eq, Ordinalize)]
-#[ordinalize(impl_trait = false)]
-#[ordinalize(variant_count(pub const VARIANT_COUNT, doc = "The count of variants."))]
-#[ordinalize(variants(pub const VARIANTS, doc = "List of this enum's variants."))]
-#[ordinalize(values(pub const VALUES, doc = "List of values for all variants of this enum."))]
-#[ordinalize(ordinal(pub const fn ordinal, doc = "Retrieve the integer number of this variant."))]
-#[ordinalize(from_ordinal(pub const fn from_ordinal, doc = "Obtain a variant based on an integer number."))]
-#[ordinalize(from_ordinal_unsafe(
-    pub const fn from_ordinal_unsafe,
-    doc = "Obtain a variant based on an integer number.",
-    doc = "# Safety",
-    doc = "You have to ensure that the input integer number can correspond to a variant on your own.",
-))]
-enum MyEnum {
-    A,
-    B,
-}
-
-assert_eq!(2, MyEnum::VARIANT_COUNT);
-assert_eq!([MyEnum::A, MyEnum::B], MyEnum::VARIANTS);
-assert_eq!([0i8, 1i8], MyEnum::VALUES);
-
-assert_eq!(0i8, MyEnum::A.ordinal());
-assert_eq!(1i8, MyEnum::B.ordinal());
-
-assert_eq!(Some(MyEnum::A), MyEnum::from_ordinal(0i8));
-assert_eq!(Some(MyEnum::B), MyEnum::from_ordinal(1i8));
-
-assert_eq!(MyEnum::A, unsafe { MyEnum::from_ordinal_unsafe(0i8) });
-assert_eq!(MyEnum::B, unsafe { MyEnum::from_ordinal_unsafe(1i8) });
-# }
-```
-*/
-
-#![no_std]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
-
-#[cfg(feature = "traits")]
-mod traits;
-
-#[cfg(feature = "derive")]
-pub use enum_ordinalize_derive::Ordinalize;
-#[cfg(feature = "traits")]
-pub use traits::Ordinalize;
diff --git a/vendor/enum-ordinalize/src/traits.rs b/vendor/enum-ordinalize/src/traits.rs
deleted file mode 100644
index f63fa3ff..00000000
--- a/vendor/enum-ordinalize/src/traits.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-/// This trait provides an enum with the ability to not only obtain the ordinal values of its variants but also allows for the construction of enums from an ordinal value.
-///
-/// ```rust
-/// use enum_ordinalize::Ordinalize;
-///
-/// #[repr(u8)]
-/// enum E {
-///     A,
-///     B,
-/// }
-///
-/// impl Ordinalize for E {
-///     type VariantType = u8;
-///
-///     const VALUES: &'static [Self::VariantType] = &[0, 1];
-///     const VARIANTS: &'static [Self] = &[E::A, E::B];
-///     const VARIANT_COUNT: usize = 2;
-///
-///     #[inline]
-///     unsafe fn from_ordinal_unsafe(number: Self::VariantType) -> Self {
-///         ::core::mem::transmute(number)
-///     }
-///
-///     #[inline]
-///     fn from_ordinal(number: Self::VariantType) -> Option<Self> {
-///         match number {
-///             0 => Some(Self::A),
-///             1 => Some(Self::B),
-///             _ => None,
-///         }
-///     }
-///
-///     #[inline]
-///     fn ordinal(&self) -> Self::VariantType {
-///         match self {
-///             Self::A => 0,
-///             Self::B => 1,
-///         }
-///     }
-/// }
-/// ```
-pub trait Ordinalize: Sized + 'static {
-    /// The type of the values of the variants.
-    type VariantType;
-
-    /// The count of variants.
-    const VARIANT_COUNT: usize;
-
-    /// List of this enum's variants.
-    const VARIANTS: &'static [Self];
-
-    /// List of values for all variants of this enum.
-    const VALUES: &'static [Self::VariantType];
-
-    /// Obtain a variant based on an integer number.
-    ///
-    /// # Safety
-    /// You have to ensure that the input integer number can correspond to a variant on your own.
-    unsafe fn from_ordinal_unsafe(number: Self::VariantType) -> Self;
-
-    /// Obtain a variant based on an integer number.
-    fn from_ordinal(number: Self::VariantType) -> Option<Self>
-    where
-        Self: Sized;
-
-    /// Retrieve the integer number of this variant.
-    fn ordinal(&self) -> Self::VariantType;
-}