Struct LegacyAppPathString 

pub struct LegacyAppPathString(/* private fields */);

A UTF-8 path for preserving raw path compatibility at the app-server API boundary while Codex migrates to PathUri.

Supports storing arbitrary strings read from the API and converting to and from PathUri using an explicitly selected native path convention.

When converting from PathUri, “native” refers to the supplied PathConvention, which may be foreign to the operating system running this process. The inner string is private so path-producing code must use a path conversion method instead of bypassing the intended conversion boundary. Non-UTF-8 paths are converted to UTF-8 lossily because this API value is serialized as a JSON string.

Deserialization and Self::from_string accept any UTF-8 string without interpreting or validating it. Use Self::from_string when a caller already owns legacy app-server path text and needs to preserve its wire spelling; use Self::from_path, Self::from_abs_path, or Self::from_path_uri when converting an actual path value. Relative path text remains valid until an operation such as Self::to_path_uri requires an absolute path.

Implementations

impl LegacyAppPathString

pub fn from_string(path: impl Into<String>) -> Self

Preserves already-legacy app-server path text without interpreting it using the current host.

This is for API-boundary values that are already strings, including relative or foreign-platform spellings. Callers with a local Path, AbsolutePathBuf, or PathUri should use the corresponding typed constructor instead.

pub fn from_path(path: &Path) -> Self

Preserves path text without interpreting it using the current host.

pub fn from_abs_path(path: &AbsolutePathBuf) -> Self

Renders an absolute path using the current host’s path convention.

pub fn from_path_uri( path: &PathUri, convention: PathConvention, ) -> Result<Self, LegacyAppPathStringError>

Renders a path URI using the requested native path convention.

Rendering fails when the URI shape does not match the convention, such as a POSIX path rendered as Windows or a UNC path rendered as POSIX. It also fails when an opaque fallback does not encode an absolute path for the convention. Non-UTF-8 segments are rendered lossily, and encoded separators are emitted as native path text.

pub fn to_path_uri( &self, convention: PathConvention, ) -> Result<PathUri, LegacyAppPathStringError>

Parses this API string as an absolute path using the requested native path convention and returns its canonical path URI.

pub fn to_inferred_path_uri(&self) -> Option<PathUri>

Parses this API string as an absolute path using the convention inferred from its spelling.

pub fn render_for_ui(&self) -> String

Renders this API path for display in a user interface.

Absolute paths are normalized using their inferred native convention. Strings that cannot be interpreted as absolute paths retain their raw API spelling.

pub fn to_inferred_abs_path(&self) -> Option<AbsolutePathBuf>

Parses this API string as a host-native absolute path.

pub fn infer_absolute_path_convention(&self) -> Option<PathConvention>

Infers the path convention of an absolute API path from its spelling.

Relative paths and ambiguous spellings return None. In particular, slash-prefixed paths are treated as POSIX even when they could also be interpreted as slash-delimited Windows UNC paths.

pub fn as_str(&self) -> &str

pub fn into_string(self) -> String

Trait Implementations

impl Clone for LegacyAppPathString

fn clone(&self) -> LegacyAppPathString

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LegacyAppPathString

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LegacyAppPathString

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for LegacyAppPathString

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for LegacyAppPathString

impl From<AbsolutePathBuf> for LegacyAppPathString

fn from(path: AbsolutePathBuf) -> Self

Converts to this type from the input type.

impl From<PathUri> for LegacyAppPathString

fn from(path: PathUri) -> Self

Converts to this type from the input type.

impl Hash for LegacyAppPathString

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl JsonSchema for LegacyAppPathString

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

impl PartialEq for LegacyAppPathString

fn eq(&self, other: &LegacyAppPathString) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for LegacyAppPathString

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LegacyAppPathString

impl TS for LegacyAppPathString

type WithoutGenerics = LegacyAppPathString

If this type does not have generic parameters, then WithoutGenerics should just be Self. If the type does have generic parameters, then all generic parameters must be replaced with a dummy type, e.g ts_rs::Dummy or (). The only requirement for these dummy types is that EXPORT_TO must be None.

type OptionInnerType = LegacyAppPathString

If the implementing type is std::option::Option<T>, then this associated type is set to T. All other implementations of TS should set this type to Self instead.

fn ident() -> String

Identifier of this type, excluding generic parameters.

fn docs() -> Option<String>

JSDoc comment to describe this type in TypeScript - when TS is derived, docs are automatically read from your doc comments or #[doc = ".."] attributes

fn name() -> String

Name of this type in TypeScript, including generic parameters

fn decl_concrete() -> String

Declaration of this type using the supplied generic arguments. The resulting TypeScript definition will not be generic. For that, see TS::decl(). If this type is not generic, then this function is equivalent to TS::decl().

fn decl() -> String

Declaration of this type, e.g. type User = { user_id: number, ... }. This function will panic if the type has no declaration.

fn inline() -> String

Formats this types definition in TypeScript, e.g { user_id: number }. This function will panic if the type cannot be inlined.

fn inline_flattened() -> String

Flatten a type declaration.
This function will panic if the type cannot be flattened.

fn visit_generics(v: &mut impl TypeVisitor)

where Self: 'static,

Iterates over all type parameters of this type.

fn output_path() -> Option<PathBuf>

Returns the output path to where T should be exported.
The returned path does not include the base directory from TS_RS_EXPORT_DIR.

fn visit_dependencies(v: &mut impl TypeVisitor)

where Self: 'static,

Iterates over all dependency of this type.

fn dependencies() -> Vec<Dependency>

where Self: 'static,

Resolves all dependencies of this type recursively.

fn export() -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem. To export this type together with all of its dependencies, use TS::export_all.

fn export_all() -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem, together with all of its dependencies.
To export only this type, without its dependencies, use TS::export.

fn export_all_to(out_dir: impl AsRef<Path>) -> Result<(), ExportError>

where Self: 'static,

Manually export this type into the given directory, together with all of its dependencies.
To export only this type, without its dependencies, use TS::export.

fn export_to_string() -> Result<String, ExportError>

where Self: 'static,

Manually generate bindings for this type, returning a String.
This function does not format the output, even if the format feature is enabled.

fn default_output_path() -> Option<PathBuf>

Returns the output path to where T should be exported.

impl TryFrom<LegacyAppPathString> for PathUri

type Error = LegacyAppPathStringError

The type returned in the event of a conversion error.

fn try_from(path: LegacyAppPathString) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<LegacyAppPathString> for AbsolutePathBuf

type Error = LegacyAppPathStringError

The type returned in the event of a conversion error.

fn try_from(path: LegacyAppPathString) -> Result<Self, Self::Error>

Performs the conversion.