use std::time;

    use git_ref_format as format;    // Then, external dependencies.

    use crate::crypto::PublicKey;    // Finally, local crate imports.

    use crate::storage::refs::Refs;

 "log",

 "multibase",

 "nonempty 0.9.0",

 "pretty_assertions",

 "qcheck",

 "qcheck-macros",

 "git2",

 "log",

 "nonempty 0.9.0",

 "qcheck",

 "qcheck-macros",

 "radicle-crypto",

 "log",

 "netservices",

 "nonempty 0.9.0",

 "qcheck",

 "qcheck-macros",

 "radicle",

name = "radicle-schemars"

version = "0.1.0"

dependencies = [

 "radicle",

 "schemars",

 "serde",

 "git2",

 "inquire",

 "libc",

 "pretty_assertions",

 "radicle-signals",

 "shlex",

fastrand = { version = "2.0.0" }

log = { version = "0.4.17" }

nonempty = { version = "0.9.0", features = ["serialize"] }

radicle-git-ext = { version = "0.8.0", features = ["serde"] }

serde_json = { version = "1.0" }

signature = { version = "2.2" }

use std::collections::BTreeMap;

use std::convert::TryFrom;

use std::path::PathBuf;

use git_ext::author::Author;

use git_ext::commit::{headers::Headers, Commit};

use git_ext::Oid;

use nonempty::NonEmpty;

use radicle_git_ext::commit::trailers::OwnedTrailer;

use crate::change::store::Version;

/// Name of the COB manifest file.

pub const MANIFEST_BLOB_NAME: &str = "manifest";

/// Path under which COB embeds are kept.

pub mod error {

    use std::str::Utf8Error;

localtime = { version = "1.2.0" }

netservices = { version = "0.8.0", features = ["io-reactor", "socket2"] }

nonempty = { version = "0.9.0", features = ["serialize"] }

qcheck = { version = "1", default-features = false, optional = true }

# N.b. this is required to use macros, even though it's re-exported

# through radicle

pub mod store;

use std::str::FromStr;

use super::*;

use crate::{PROTOCOL_VERSION, VERSION};

use radicle::node::UserAgent;

pub use store::{AnnouncementId, Error, RelayStatus, Store};

/// This node's user agent string.

    FromStr::from_str(format!("/radicle:{}/", VERSION.version).as_str())

        .expect("user agent is valid")

});

use std::env;

use std::io;

use std::sync::Arc;

use std::time;

use crossbeam_channel as chan;

use netservices::Direction as Link;

use radicle::identity::Visibility;

use radicle::node::address::Store as _;

use radicle::node::device::Device;

/// Default number of tests to run when testing things with high variance.

pub const DEFAULT_TEST_CASES: usize = 10;

/// Test cases to run when testing things with high variance.

    env::var("RAD_TEST_CASES")

        .ok()

        .and_then(|s| s.parse::<usize>().ok())

path = "src/main.rs"

[dependencies]

schemars = { workspace = true }

serde = { version = "1.0" }

serde_json = { version = "1" }

use std::io;

use std::net;

use schemars::{generate::*, *};

const SCHEMA_COMMAND: &str = "radicle::node::Command";

const SCHEMAS: &[&str] = &[SCHEMA_COMMAND, SCHEMA_COMMAND_RESULT, SCHEMA_PROFILE_CONFIG];

    let schemas = SCHEMAS.to_vec().join("\", \"");

    format!("Expected exactly one of the following schema names: [\"{schemas}\"].")

});

crossbeam-channel = { version = "0.5.6" }

inquire = { version = "0.7.4", default-features = false, features = ["termion", "editor"] }

libc = { version = "0.2" }

shlex = { version = "1.1" }

termion = { version = "3" }

thiserror = { version = "1" }

use std::io::IsTerminal as _;

use std::os::fd::{AsRawFd, BorrowedFd};

use std::sync::atomic::{AtomicBool, AtomicI32};

use std::{fmt, sync};

use super::color::Color;

use super::style::{Property, Style};

    /// Check 24-bit RGB color support.

    pub fn truecolor() -> bool {

        *TRUECOLOR

    }

use std::ffi::OsStr;

use std::fmt::Write;

use std::process::Stdio;

use std::{env, fmt, io, process};

use inquire::ui::{ErrorMessageRenderConfig, StyleSheet, Styled};

use inquire::validator;

use inquire::InquireError;

use inquire::{ui::Color, ui::RenderConfig, Confirm, CustomType, Password};

use zeroize::Zeroizing;

use crate::command;

pub type Passphrase = Zeroizing<String>;

/// Render configuration.

    prompt: StyleSheet::new().with_fg(Color::LightCyan),

    prompt_prefix: Styled::new("?").with_fg(Color::LightBlue),

    answered_prompt_prefix: Styled::new("✓").with_fg(Color::LightGreen),

libc = { version = "0.2" }

log = { version = "0.4.17", features = ["std"] }

nonempty = { version = "0.9.0", features = ["serialize"] }

serde = { version = "1", features = ["derive"] }

serde_json = { version = "1", features = ["preserve_order"] }

siphasher = { version = "1.0.0" }

use std::collections::BTreeMap;

use std::{fmt, ops::Deref, str::FromStr};

use crypto::{PublicKey, Signature};

use radicle_cob::{Embed, ObjectId, TypeName};

use radicle_git_ext as git_ext;

use radicle_git_ext::Oid;

use super::{Author, EntryId};

/// Type name of an identity proposal.

/// Identity operation.

pub type Op = cob::Op<Action>;

use std::collections::BTreeSet;

use std::ops::Deref;

use std::str::FromStr;

use serde::{Deserialize, Serialize};

use thiserror::Error;

pub type Op = cob::Op<Action>;

/// Type name of an issue.

/// Identifier for an issue.

pub type IssueId = ObjectId;

use std::fmt;

use std::ops::Deref;

use std::str::FromStr;

use amplify::Wrapper;

use nonempty::NonEmpty;

use serde::{Deserialize, Serialize};

use storage::{HasRepoId, RepositoryError};

use thiserror::Error;

pub use cache::Cache;

/// Type name of a patch.

/// Patch operation.

pub type Op = cob::Op<Action>;

use std::cmp::Ordering;

use std::collections::{BTreeMap, BTreeSet};

use std::str::FromStr;

use serde::{ser::SerializeStruct, Deserialize, Serialize};

use thiserror::Error;

/// Type name of a thread, as well as the domain for all thread operations.

/// Note that threads are not usually used standalone. They are embeded into other COBs.

/// Error applying an operation onto a state.

#[derive(Error, Debug)]

use std::path::Path;

use std::process::Command;

use std::str::FromStr;

use git_ext::ref_format as format;

use crate::collections::RandomMap;

use crate::crypto::PublicKey;

        ///

        /// `refs/rad/id`

        ///

            Qualified::from_components(name::component!("rad"), name::component!("id"), None)

        });

        ///

        /// `refs/rad/root`

        ///

            Qualified::from_components(name::component!("rad"), name::component!("root"), None)

        });

        ///

        /// `refs/rad/sigrefs`

        ///

            Qualified::from_components(name::component!("rad"), name::component!("sigrefs"), None)

        });

use std::ops::{Deref, Not};

use std::path::Path;

use std::str::FromStr;

use nonempty::NonEmpty;

use radicle_cob::type_name::{TypeName, TypeNameParse};

use radicle_git_ext::Oid;

use serde::{de, Deserialize, Serialize};

pub use id::*;

/// Path to the identity document in the identity branch.

/// Maximum length of a string in the identity document.

pub const MAX_STRING_LENGTH: usize = 255;

/// Maximum number of a delegates in the identity document.

    use std::str::FromStr;

    use super::{ConnectAddress, PeerAddr};

    /// A public Radicle seed node for the community.

        // SAFETY: `ConnectAddress` is known at compile time.

        #[allow(clippy::unwrap_used)]

        PeerAddr::from_str("z6MkrLMMsiPWUcNPHcRajuMi9mDfYckSoJyPwwnknocNYPm7@iris.radicle.xyz:8776")

    });

    /// A public Radicle seed node for the community.

        // SAFETY: `ConnectAddress` is known at compile time.

        #[allow(clippy::unwrap_used)]

        PeerAddr::from_str("z6Mkmqogy2qEM2ummccUthFEaaHvyYmYBYh3dbe9W4ebScxo@rosa.radicle.xyz:8776")

    });

    /// The Radicle seed node that the Radicle team uses.

        // SAFETY: `ConnectAddress` is known at compile time.

        #[allow(clippy::unwrap_used)]

        PeerAddr::from_str("z6MksmpU5b1dS7oaqF2bHXhQi1DWy2hB7Mh9CuN7y1DN6QSz@seed.radicle.xyz:8776")

use std::io;

use std::path::{Path, PathBuf};

use std::str::FromStr;

use thiserror::Error;

use crate::cob::ObjectId;

use crate::{identity, storage};

/// Name of the radicle storage remote.

/// Name of the radicle storage remote.

/// Refname used for pushing patches.

#[derive(Error, Debug)]

pub enum InitError {

use std::collections::{BTreeMap, BTreeSet, HashMap};

use std::ops::{Deref, DerefMut};

use std::path::{Path, PathBuf};

use std::{fs, io};

use crypto::Verified;

use tempfile::TempDir;

use crate::git::canonical::Canonical;

use super::refs::RefsAt;

use super::{RemoteId, RemoteRepository, ValidateRepository};

    git::Qualified::from_components(

        git::name::component!("rad"),

        git::name::component!("id"),

use std::collections::HashMap;

use std::path::{Path, PathBuf};

use std::str::FromStr;

use std::sync::{Mutex, Once};

use std::thread::ThreadId;

use std::{process, thread};

use super::Url;

use crate::storage::git::transport::ChildStream;

use crate::storage::RemoteId;

/// Nodes registered with the mock transport.

/// The mock transport.

#[derive(Default)]