// Generated by Lisette bindgen
// Source: crypto/ecdsa (Go stdlib)
// Go: 1.25.10
// Lisette: 0.3.0

import "go:crypto"
import "go:crypto/ecdh"
import "go:crypto/elliptic"
import "go:io"
import "go:math/big"

/// GenerateKey generates a new ECDSA private key for the specified curve.
/// 
/// Most applications should use [crypto/rand.Reader] as rand. Note that the
/// returned key does not depend deterministically on the bytes read from rand,
/// and may change between calls and/or between versions.
pub fn GenerateKey(c: elliptic.Curve, rand: io.Reader) -> Result<Ref<PrivateKey>, error>

/// ParseRawPrivateKey parses a private key encoded as a fixed-length big-endian
/// integer, according to SEC 1, Version 2.0, Section 2.3.6 (sometimes referred
/// to as the raw format). It returns an error if the value is not reduced modulo
/// the curve's order, or if it's zero.
/// 
/// curve must be one of [elliptic.P224], [elliptic.P256], [elliptic.P384], or
/// [elliptic.P521], or ParseRawPrivateKey returns an error.
/// 
/// ParseRawPrivateKey accepts the same format as [ecdh.Curve.NewPrivateKey] does
/// for NIST curves, but returns a [PrivateKey] instead of an [ecdh.PrivateKey].
/// 
/// Note that private keys are more commonly encoded in ASN.1 or PKCS#8 format,
/// which can be parsed with [crypto/x509.ParseECPrivateKey] or
/// [crypto/x509.ParsePKCS8PrivateKey] (and [encoding/pem]).
pub fn ParseRawPrivateKey(curve: elliptic.Curve, data: Slice<byte>) -> Result<Ref<PrivateKey>, error>

/// ParseUncompressedPublicKey parses a public key encoded as an uncompressed
/// point according to SEC 1, Version 2.0, Section 2.3.3 (also known as the X9.62
/// uncompressed format). It returns an error if the point is not in uncompressed
/// form, is not on the curve, or is the point at infinity.
/// 
/// curve must be one of [elliptic.P224], [elliptic.P256], [elliptic.P384], or
/// [elliptic.P521], or ParseUncompressedPublicKey returns an error.
/// 
/// ParseUncompressedPublicKey accepts the same format as
/// [ecdh.Curve.NewPublicKey] does for NIST curves, but returns a [PublicKey]
/// instead of an [ecdh.PublicKey].
/// 
/// Note that public keys are more commonly encoded in DER (or PEM) format, which
/// can be parsed with [crypto/x509.ParsePKIXPublicKey] (and [encoding/pem]).
pub fn ParseUncompressedPublicKey(curve: elliptic.Curve, data: Slice<byte>) -> Result<Ref<PublicKey>, error>

/// Sign signs a hash (which should be the result of hashing a larger message)
/// using the private key, priv. If the hash is longer than the bit-length of the
/// private key's curve order, the hash will be truncated to that length. It
/// returns the signature as a pair of integers. Most applications should use
/// [SignASN1] instead of dealing directly with r, s.
pub fn Sign(rand: io.Reader, priv: Ref<PrivateKey>, hash: Slice<byte>) -> Result<(Ref<big.Int>, Ref<big.Int>), error>

/// SignASN1 signs a hash (which should be the result of hashing a larger message)
/// using the private key, priv. If the hash is longer than the bit-length of the
/// private key's curve order, the hash will be truncated to that length. It
/// returns the ASN.1 encoded signature.
/// 
/// The signature is randomized. Most applications should use [crypto/rand.Reader]
/// as rand. Note that the returned signature does not depend deterministically on
/// the bytes read from rand, and may change between calls and/or between versions.
pub fn SignASN1(rand: io.Reader, priv: Ref<PrivateKey>, hash: Slice<byte>) -> Result<Slice<byte>, error>

/// Verify verifies the signature in r, s of hash using the public key, pub. Its
/// return value records whether the signature is valid. Most applications should
/// use VerifyASN1 instead of dealing directly with r, s.
/// 
/// The inputs are not considered confidential, and may leak through timing side
/// channels, or if an attacker has control of part of the inputs.
pub fn Verify(
  pub_: Ref<PublicKey>,
  hash: Slice<byte>,
  r: Ref<big.Int>,
  s: Ref<big.Int>,
) -> bool

/// VerifyASN1 verifies the ASN.1 encoded signature, sig, of hash using the
/// public key, pub. Its return value records whether the signature is valid.
/// 
/// The inputs are not considered confidential, and may leak through timing side
/// channels, or if an attacker has control of part of the inputs.
pub fn VerifyASN1(pub_: Ref<PublicKey>, hash: Slice<byte>, sig: Slice<byte>) -> bool

/// PrivateKey represents an ECDSA private key.
pub struct PrivateKey {
  pub PublicKey: PublicKey,
  pub D: Option<Ref<big.Int>>,
}

/// PublicKey represents an ECDSA public key.
pub struct PublicKey {
  pub Curve: Option<elliptic.Curve>,
  pub X: Option<Ref<big.Int>>,
  pub Y: Option<Ref<big.Int>>,
}

impl PrivateKey {
  /// Add returns the sum of (x1,y1) and (x2,y2).
  /// 
  /// Deprecated: this is a low-level unsafe API.
  fn Add(
    self,
    x1: Ref<big.Int>,
    y1: Ref<big.Int>,
    x2: Ref<big.Int>,
    y2: Ref<big.Int>,
  ) -> (Ref<big.Int>, Ref<big.Int>)

  /// Bytes encodes the private key as a fixed-length big-endian integer according
  /// to SEC 1, Version 2.0, Section 2.3.6 (sometimes referred to as the raw
  /// format). It returns an error if the private key is invalid.
  /// 
  /// PrivateKey.Curve must be one of [elliptic.P224], [elliptic.P256],
  /// [elliptic.P384], or [elliptic.P521], or Bytes returns an error.
  /// 
  /// Bytes returns the same format as [ecdh.PrivateKey.Bytes] does for NIST curves.
  /// 
  /// Note that private keys are more commonly encoded in ASN.1 or PKCS#8 format,
  /// which can be generated with [crypto/x509.MarshalECPrivateKey] or
  /// [crypto/x509.MarshalPKCS8PrivateKey] (and [encoding/pem]).
  fn Bytes(self: Ref<PrivateKey>) -> Result<Slice<byte>, error>

  /// Double returns 2*(x,y).
  /// 
  /// Deprecated: this is a low-level unsafe API.
  fn Double(self, x1: Ref<big.Int>, y1: Ref<big.Int>) -> (Ref<big.Int>, Ref<big.Int>)

  /// ECDH returns k as a [ecdh.PrivateKey]. It returns an error if the key is
  /// invalid according to the definition of [ecdh.Curve.NewPrivateKey], or if the
  /// Curve is not supported by [crypto/ecdh].
  fn ECDH(self: Ref<PrivateKey>) -> Result<Ref<ecdh.PrivateKey>, error>

  /// Equal reports whether priv and x have the same value.
  /// 
  /// See [PublicKey.Equal] for details on how Curve is compared.
  fn Equal(self: Ref<PrivateKey>, x: crypto.PrivateKey) -> bool

  /// IsOnCurve reports whether the given (x,y) lies on the curve.
  /// 
  /// Deprecated: this is a low-level unsafe API. For ECDH, use the crypto/ecdh
  /// package. The NewPublicKey methods of NIST curves in crypto/ecdh accept
  /// the same encoding as the Unmarshal function, and perform on-curve checks.
  fn IsOnCurve(self, x: Ref<big.Int>, y: Ref<big.Int>) -> bool

  /// Params returns the parameters for the curve.
  fn Params(self) -> Ref<elliptic.CurveParams>

  /// Public returns the public key corresponding to priv.
  fn Public(self: Ref<PrivateKey>) -> crypto.PublicKey

  /// ScalarBaseMult returns k*G, where G is the base point of the group
  /// and k is an integer in big-endian form.
  /// 
  /// Deprecated: this is a low-level unsafe API. For ECDH, use the crypto/ecdh
  /// package. Most uses of ScalarBaseMult can be replaced by a call to the
  /// PrivateKey.PublicKey method in crypto/ecdh.
  fn ScalarBaseMult(self, k: Slice<byte>) -> (Ref<big.Int>, Ref<big.Int>)

  /// ScalarMult returns k*(x,y) where k is an integer in big-endian form.
  /// 
  /// Deprecated: this is a low-level unsafe API. For ECDH, use the crypto/ecdh
  /// package. Most uses of ScalarMult can be replaced by a call to the ECDH
  /// methods of NIST curves in crypto/ecdh.
  fn ScalarMult(self, x1: Ref<big.Int>, y1: Ref<big.Int>, k: Slice<byte>) -> (Ref<big.Int>, Ref<big.Int>)

  /// Sign signs a hash (which should be the result of hashing a larger message
  /// with opts.HashFunc()) using the private key, priv. If the hash is longer than
  /// the bit-length of the private key's curve order, the hash will be truncated
  /// to that length. It returns the ASN.1 encoded signature, like [SignASN1].
  /// 
  /// If rand is not nil, the signature is randomized. Most applications should use
  /// [crypto/rand.Reader] as rand. Note that the returned signature does not
  /// depend deterministically on the bytes read from rand, and may change between
  /// calls and/or between versions.
  /// 
  /// If rand is nil, Sign will produce a deterministic signature according to RFC
  /// 6979. When producing a deterministic signature, opts.HashFunc() must be the
  /// function used to produce digest and priv.Curve must be one of
  /// [elliptic.P224], [elliptic.P256], [elliptic.P384], or [elliptic.P521].
  fn Sign(
    self: Ref<PrivateKey>,
    rand: io.Reader,
    digest: Slice<byte>,
    opts: crypto.SignerOpts,
  ) -> Result<Slice<byte>, error>
}

impl PublicKey {
  /// Add returns the sum of (x1,y1) and (x2,y2).
  /// 
  /// Deprecated: this is a low-level unsafe API.
  fn Add(
    self,
    x1: Ref<big.Int>,
    y1: Ref<big.Int>,
    x2: Ref<big.Int>,
    y2: Ref<big.Int>,
  ) -> (Ref<big.Int>, Ref<big.Int>)

  /// Bytes encodes the public key as an uncompressed point according to SEC 1,
  /// Version 2.0, Section 2.3.3 (also known as the X9.62 uncompressed format).
  /// It returns an error if the public key is invalid.
  /// 
  /// PublicKey.Curve must be one of [elliptic.P224], [elliptic.P256],
  /// [elliptic.P384], or [elliptic.P521], or Bytes returns an error.
  /// 
  /// Bytes returns the same format as [ecdh.PublicKey.Bytes] does for NIST curves.
  /// 
  /// Note that public keys are more commonly encoded in DER (or PEM) format, which
  /// can be generated with [crypto/x509.MarshalPKIXPublicKey] (and [encoding/pem]).
  fn Bytes(self: Ref<PublicKey>) -> Result<Slice<byte>, error>

  /// Double returns 2*(x,y).
  /// 
  /// Deprecated: this is a low-level unsafe API.
  fn Double(self, x1: Ref<big.Int>, y1: Ref<big.Int>) -> (Ref<big.Int>, Ref<big.Int>)

  /// ECDH returns k as a [ecdh.PublicKey]. It returns an error if the key is
  /// invalid according to the definition of [ecdh.Curve.NewPublicKey], or if the
  /// Curve is not supported by crypto/ecdh.
  fn ECDH(self: Ref<PublicKey>) -> Result<Ref<ecdh.PublicKey>, error>

  /// Equal reports whether pub and x have the same value.
  /// 
  /// Two keys are only considered to have the same value if they have the same Curve value.
  /// Note that for example [elliptic.P256] and elliptic.P256().Params() are different
  /// values, as the latter is a generic not constant time implementation.
  fn Equal(self: Ref<PublicKey>, x: crypto.PublicKey) -> bool

  /// IsOnCurve reports whether the given (x,y) lies on the curve.
  /// 
  /// Deprecated: this is a low-level unsafe API. For ECDH, use the crypto/ecdh
  /// package. The NewPublicKey methods of NIST curves in crypto/ecdh accept
  /// the same encoding as the Unmarshal function, and perform on-curve checks.
  fn IsOnCurve(self, x: Ref<big.Int>, y: Ref<big.Int>) -> bool

  /// Params returns the parameters for the curve.
  fn Params(self) -> Ref<elliptic.CurveParams>

  /// ScalarBaseMult returns k*G, where G is the base point of the group
  /// and k is an integer in big-endian form.
  /// 
  /// Deprecated: this is a low-level unsafe API. For ECDH, use the crypto/ecdh
  /// package. Most uses of ScalarBaseMult can be replaced by a call to the
  /// PrivateKey.PublicKey method in crypto/ecdh.
  fn ScalarBaseMult(self, k: Slice<byte>) -> (Ref<big.Int>, Ref<big.Int>)

  /// ScalarMult returns k*(x,y) where k is an integer in big-endian form.
  /// 
  /// Deprecated: this is a low-level unsafe API. For ECDH, use the crypto/ecdh
  /// package. Most uses of ScalarMult can be replaced by a call to the ECDH
  /// methods of NIST curves in crypto/ecdh.
  fn ScalarMult(self, x1: Ref<big.Int>, y1: Ref<big.Int>, k: Slice<byte>) -> (Ref<big.Int>, Ref<big.Int>)
}
