rork-xcode 0.2.0 → 0.4.0

package/README.md

@@ -3,7 +3,7 @@
 [![CI](https://github.com/rorkai/rork-xcode/actions/workflows/ci.yml/badge.svg)](https://github.com/rorkai/rork-xcode/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/rork-xcode)](https://www.npmjs.com/package/rork-xcode)
 
-The [fastest](#performance) zero-dependency Xcode project (`project.pbxproj`) parser, builder, and object model for any JavaScript runtime: browsers, Node.js, Bun, Electron, Cloudflare Workers, and React Native.
+The [fastest](#performance) zero-dependency Xcode project (`project.pbxproj`) parser, builder, and object model for any JavaScript runtime: browsers, Node.js, Bun, Electron, Cloudflare Workers, and React Native. [Scheme files](#schemes) (`.xcscheme`) are covered with the same round-trip guarantees.
 
 ```ts
 import { parsePbxproj, buildPbxproj } from "rork-xcode";
@@ -25,11 +25,11 @@ const text = buildPbxproj(project); // byte-stable, Xcode-canonical layout
 
 `rork-xcode` is designed for exactly that situation:
 
-- **Zero dependencies.** The pbxproj grammar is a small OpenStep-style property list dialect: dictionaries, arrays, strings, and hex data runs. A dedicated scanner covers it completely, with no general-purpose parser stack, no native addon, and no WASM blob.
+- **Zero dependencies.** The pbxproj grammar is a small OpenStep-style property list dialect of dictionaries, arrays, strings, and hex data runs. A dedicated scanner covers it completely, with no general-purpose parser stack, no native addon, and no WASM blob.
 - **One artifact, one code path.** A single ESM file with named exports. No environment-conditional entry points, no reliance on ambient globals like `Buffer`. What you test locally is what runs in production, whatever the bundler.
 - **Xcode-canonical output.** The serializer reproduces the layout Xcode itself writes (tab indentation, per-isa object sections in sorted order, single-line build-file entries, and derived reference comments like `13B07F86… /* AppDelegate.swift in Sources */`), so diffs against Xcode-saved projects stay minimal and Xcode does not rewrite the file on next save.
 - **Round-trip faithful.** Parse → build is byte-identical for Xcode-canonical documents and a fixed point for everything else. Lexical subtleties that plain number conversion would destroy (leading-zero values like `0755`, trailing-zero versions like `5.0`, digit runs longer than the double-precision safe range) are preserved as strings by design.
-- **Loud failure modes.** Malformed documents fail with a typed error carrying line and column; unrepresentable values (`null`, booleans, non-finite numbers) fail with the exact path of the offending value. Nothing is silently dropped.
+- **Loud failure modes.** Malformed documents fail with a typed error carrying line and column, and unrepresentable values (`null`, booleans, non-finite numbers) fail with the exact path of the offending value. Nothing is silently dropped.
 
 ## Install
 
@@ -222,13 +222,49 @@ for (const [id, object] of project.objects()) {
 
 ### Semantics
 
-- **Typed vocabulary, generic fallback.** The typed views cover targets of every kind, groups and variant groups, Xcode 16 synchronized folders and their exception sets, build phases and build rules, Core Data version groups, and cross-project reference proxies. Every other kind is a generic `XcodeObject` with the same read and write access, so nothing in a document is out of reach.
+- **Typed vocabulary, generic fallback.** The typed views cover targets of every kind, groups and variant groups, Xcode 16 synchronized folders and their exception sets, build phases and build rules, build configurations, file references, container item proxies, Core Data version groups, and cross-project reference proxies. Every other kind is a generic `XcodeObject` with the same read and write access, so nothing in a document is out of reach.
+- **`is()` narrowing.** Every view class carries a static type guard for discriminating mixed objects: `if (NativeTarget.is(object))` narrows the way `instanceof` does, subclasses included. Build configurations additionally expose their settings as a live typed dictionary through `configuration.buildSettings`.
 - **Typed, open property shapes.** Known keys autocomplete (`target.properties.productType`) and the shape stays open, so keys like `INFOPLIST_KEY_*` settings remain first-class. The shapes describe well-formed documents. When reading untrusted input, use the narrowing accessors, which never trust them.
-- **Two verb families.** `add*` wires something to its owner (a dependency, a package, a framework, a synchronized folder) and is idempotent: re-adding returns the existing wiring. `ensure*` returns a structural container, creating it when missing (a build phase, a group chain, the Products group). Both families can therefore run unconditionally in scaffold and repair flows.
+- **Two verb families.** `add*` wires something to its owner (a dependency, a package, a framework, a synchronized folder) and is idempotent, so re-adding returns the existing wiring. `ensure*` returns a structural container, creating it when missing (a build phase, a group chain, the Products group). Both families can therefore run unconditionally in scaffold and repair flows.
 - **Deterministic identifiers.** New objects get ids derived from what they are (`XX` + 20 digest characters + `XX`, from an embedded hash), so programmatic edits are reproducible run to run and diffs stay minimal. Collisions within a document resolve deterministically, and identical edit sequences produce byte-identical documents.
 - **Soft reads, loud writes.** Real-world projects can be malformed, so lookups return `undefined` where a document could omit something. Operations that cannot proceed without structure (no root project object, an unknown product type, a view whose object was deleted) throw `XcodeModelError`.
 - **Identity-mapped views.** Two lookups of the same id return the same instance, so views compare with `===`.
 
+## Schemes
+
+`.xcscheme` files describe how Xcode builds, runs, tests, and archives a target. They are not property lists but a small XML dialect of their own, and the scheme module covers it with the same contract as the pbxproj functions. An Xcode-written scheme rebuilds byte for byte, any other input reaches Xcode's canonical layout in one build, and malformed input fails with a typed error carrying line and column.
+
+`Xcscheme` is the model. Buildable references are the elements editing flows touch, and they come back as typed views:
+
+```ts
+import { Xcscheme } from "rork-xcode";
+
+const scheme = Xcscheme.parse(xcschemeText);
+
+// Rename the app while keeping each product's own shape, so a testable
+// like DemoAppTests.xctest stays a test bundle.
+for (const reference of scheme.buildableReferences()) {
+  const { blueprintName, buildableName } = reference;
+  if (blueprintName) reference.blueprintName = blueprintName.replace("DemoApp", "RenamedApp");
+  if (buildableName) reference.buildableName = buildableName.replace("DemoApp", "RenamedApp");
+  reference.referencedContainer = "container:RenamedApp.xcodeproj";
+}
+
+const text = scheme.build();
+```
+
+`Xcscheme.create` produces the scheme Xcode's own "New Scheme" action writes for an application target, wired to the target's object id from the project document:
+
+```ts
+const scheme = Xcscheme.create({
+  appName: "DemoApp",
+  blueprintIdentifier: app.id,
+});
+const text = scheme.build();
+```
+
+Underneath, the document is a plain tree of elements with ordered attributes and children, reachable through `scheme.root` and `scheme.elements(name)`, so anything the typed surface does not cover stays one property away. `parseXcscheme` and `buildXcscheme` remain available for working with the tree directly. Attribute order is preserved and meaningful, which is how byte-identical round-trips fall out. Comments are kept, attribute values resolve the character references Xcode writes (`"`, `&`, `
` and friends), and the writer re-escapes them identically.
+
 ## Performance
 
 `rork-xcode` is measured against the pbxproj parsers on npm, [`@bacons/xcode`](https://www.npmjs.com/package/@bacons/xcode) (its `/json` parse/build entry point) and [`xcode`](https://www.npmjs.com/package/xcode) (the long-standing package used by native build tooling), on three documents: two real Xcode-written projects from the test suite and a deterministically generated five-target app with 800 source files. It is the fastest at both operations on every document, with zero dependencies.
@@ -250,8 +286,8 @@ Measured on an Apple M5 Max, Node.js 24, single thread, with `@bacons/xcode` 1.0
 
 ### Key performance features
 
-- **Single-pass scanner.** One cursor over the input string with table-driven character classification; no tokenizer stage, no intermediate token objects.
-- **Comments skip in bulk.** Reference comments are a sizable share of a canonical document's bytes; comment bodies are jumped with `indexOf` instead of being scanned per character.
+- **Single-pass scanner.** One cursor over the input string with table-driven character classification. There is no tokenizer stage and no intermediate token objects.
+- **Comments skip in bulk.** Reference comments are a sizable share of a canonical document's bytes, so comment bodies are jumped with `indexOf` instead of being scanned per character.
 - **Linear comment derivation.** Building the `/* … */` annotations uses reverse indexes over the object graph (build file → phase, configuration list → owner), so serialization stays linear on projects with thousands of objects.
 - **Memoized rendering.** Quoting decisions for the repeated key vocabulary and rendered uuid references are cached per document, halving the quote scans on reference-heavy sections.
 
@@ -260,7 +296,7 @@ Measured on an Apple M5 Max, Node.js 24, single thread, with `@bacons/xcode` 1.0
 - The committed fixture corpus spans project generations from Xcode 3 to Xcode 16, captured from real projects with identifiers neutralized: synchronized folders with both exception-set kinds, classic groups, variant groups, aggregate and legacy targets, reference proxies, build rules, Swift packages, and a ~100 KiB multiplatform framework project.
 - Documents already in current Xcode's layout must round-trip byte for byte; documents from other tool generations must normalize to a byte-stable fixed point with unchanged values.
 - On macOS, the suite cross-validates every fixture and its rebuilt form with `plutil`, Apple's own property list parser and the empirical ground truth for what Apple tooling accepts.
-- A corpus sweep (`pnpm corpus`) walks every Xcode project on the machine, verifies each one parses and reaches a byte-stable fixed point, exercises the object model against it, and cross-validates a sample against plutil's own reading.
+- A corpus sweep (`pnpm corpus`) walks every Xcode project and scheme on the machine, verifies each one parses and reaches a byte-stable fixed point, exercises the object model against every project, and cross-validates a sample against plutil's own reading.
 - CI runs the full gate on Linux and macOS, and executes the built artifact on the oldest supported Node to enforce the `engines` floor.
 
 ## Releasing

package/dist/index.d.ts

@@ -114,6 +114,42 @@ declare class PbxprojParseError extends Error {
    */
   constructor(message: string, source: string, offset: number);
 }
+/**
+ * Thrown when the source text is not a well-formed scheme document (the
+ * XML dialect of `.xcscheme` files).
+ *
+ * The message always embeds the line and column of the failure, and the
+ * same information is available in structured form on {@link position}
+ * for programmatic use.
+ */
+declare class XcschemeParseError extends Error {
+  /** Where in the source text parsing failed. */
+  readonly position: PbxprojErrorPosition;
+  /**
+   * @param message Failure description without location; the location is
+   *   appended automatically.
+   * @param source Full source text, used to compute the position.
+   * @param offset Character offset of the failure inside `source`.
+   */
+  constructor(message: string, source: string, offset: number);
+}
+/**
+ * Thrown when a scheme element cannot be written as XML.
+ *
+ * Raised for element and attribute names that are not valid XML names and
+ * for attribute values carrying control characters XML 1.0 cannot encode.
+ * The {@link path} pinpoints the offending element inside the tree.
+ */
+declare class XcschemeBuildError extends Error {
+  /** Path to the offending element from the root, e.g. `Scheme.BuildAction[0]`. */
+  readonly path: string;
+  /**
+   * @param message Failure description without location; the element path
+   *   is appended automatically.
+   * @param path Path to the offending element from the root.
+   */
+  constructor(message: string, path: string);
+}
 /**
  * Thrown by the object model when an operation cannot proceed: the
  * document lacks the structure the operation needs (no objects dictionary,
@@ -271,6 +307,8 @@ interface BuildSettings extends PbxprojObject {
   SUPPORTED_PLATFORMS?: string;
   SWIFT_VERSION?: string;
   TARGETED_DEVICE_FAMILY?: number | string;
+  TEST_HOST?: string;
+  TEST_TARGET_NAME?: string;
   TVOS_DEPLOYMENT_TARGET?: string;
   WATCHOS_DEPLOYMENT_TARGET?: string;
   XROS_DEPLOYMENT_TARGET?: string;
@@ -852,6 +890,49 @@ declare class VersionGroup extends Group<VersionGroupProperties> {
    */
   setCurrentVersion(reference: XcodeObject): void;
 }
+/**
+ * An `XCBuildConfiguration` holds one named settings dictionary of a
+ * target or of the project, for example Debug or Release.
+ */
+declare class BuildConfiguration extends XcodeObject<BuildConfigurationProperties> {
+  /**
+   * The configuration's name, when present.
+   */
+  get name(): string | undefined;
+  /**
+   * The configuration's settings dictionary, typed with the keys
+   * programmatic edits touch most, or `undefined` when the configuration
+   * carries none. The dictionary is live. Writes through it land in the
+   * document.
+   */
+  get buildSettings(): BuildSettings | undefined;
+}
+/**
+ * A `PBXFileReference` names one file on disk, from source files to the
+ * built products themselves.
+ */
+declare class FileReference extends XcodeObject<FileReferenceProperties> {
+  /**
+   * The reference's path, relative to its `sourceTree`, when present.
+   */
+  get path(): string | undefined;
+  /**
+   * The reference's display name, when it carries one distinct from the
+   * path.
+   */
+  get name(): string | undefined;
+}
+/**
+ * A `PBXContainerItemProxy` is the indirection Xcode places between a
+ * target dependency and the target it points at.
+ */
+declare class ContainerItemProxy extends XcodeObject<ContainerItemProxyProperties> {
+  /**
+   * The display name of the object the proxy points at, when present.
+   * For target dependencies this is the target's name.
+   */
+  get remoteInfo(): string | undefined;
+}
 /**
  * A `PBXReferenceProxy` stands in for a product built by a target of
  * another project referenced from this one.
@@ -1177,15 +1258,32 @@ declare class XcodeObject<Properties extends PbxprojObject = PbxprojObject> {
   /** The object's 24-character identifier (its key in `objects`). */
   readonly id: string;
   /**
-   * Views are created by the project's identity map; use
+   * Views are created by the project's identity map. Use
    * {@link XcodeProject.get} or a typed query instead of constructing
    * views directly.
    */
   constructor(project: XcodeProject, id: string);
   /**
-   * The object's raw dictionary inside the document. Mutations through the
-   * model write here, and direct writes are equally valid; the model adds
-   * no caching over these properties.
+   * Whether a value is a view of this class, narrowing it when so. Views
+   * come typed out of the factory, and this is the readable way to
+   * discriminate them when iterating mixed objects.
+   *
+   * ```ts
+   * for (const [, object] of project.objects()) {
+   *   if (NativeTarget.is(object)) {
+   *     console.log(object.name);
+   *   }
+   * }
+   * ```
+   *
+   * Subclass views match their parent class too, the way `instanceof`
+   * does, so a `VersionGroup` is a `Group`.
+   */
+  static is<Constructor extends abstract new (...args: never) => unknown>(this: Constructor, value: unknown): value is InstanceType<Constructor>;
+  /**
+   * The object's raw dictionary inside the document. Mutations through
+   * the model write here, direct writes are equally valid, and the model
+   * adds no caching over these properties.
    *
    * The typed shape is asserted, not checked. It describes what a
    * well-formed object of this kind carries (see `properties.ts`).
@@ -1245,6 +1343,210 @@ declare class XcodeObject<Properties extends PbxprojObject = PbxprojObject> {
  */
 declare function parsePbxproj(text: string): PbxprojValue;
 //#endregion
+//#region src/scheme/types.d.ts
+/**
+ * The node model of a scheme document.
+ *
+ * A parsed `.xcscheme` is a tree of plain objects. Elements carry ordered
+ * attributes and child nodes, and comments survive as their own nodes.
+ * All state lives in this tree. There is no wrapper to keep in sync, so
+ * callers mutate nodes directly and serialize whatever the tree currently
+ * says.
+ *
+ * @module
+ */
+/**
+ * An XML element of a scheme document.
+ *
+ * Attribute order is preserved and meaningful. The writer emits
+ * attributes in insertion order, which is how Xcode-written files
+ * round-trip byte-identically. Assigning an existing key keeps its
+ * position, and adding a new key appends it.
+ */
+interface XcschemeElement {
+  /** Tag name, for example `Scheme` or `BuildableReference`. */
+  name: string;
+  /** Attribute values by name, in document order. */
+  attributes: Record<string, string>;
+  /** Child elements and comments, in document order. */
+  children: XcschemeNode[];
+}
+/**
+ * A comment inside a scheme document. Xcode never writes comments, but
+ * hand-edited and tool-generated schemes can carry them, and dropping
+ * them would make round-trips lossy.
+ */
+interface XcschemeComment {
+  /** The comment text between `<!--` and `-->`, verbatim. */
+  comment: string;
+}
+/**
+ * Any node a scheme element can contain.
+ */
+type XcschemeNode = XcschemeElement | XcschemeComment;
+/**
+ * A parsed scheme file, made of its root element plus any comments
+ * sitting outside it. Xcode writes only the root, so the comment lists
+ * are almost always empty, but files that carry them round-trip without
+ * loss.
+ */
+interface XcschemeDocument {
+  /** Comments before the root element. */
+  leading: XcschemeComment[];
+  /** The `Scheme` element. */
+  root: XcschemeElement;
+  /** Comments after the root element. */
+  trailing: XcschemeComment[];
+}
+/**
+ * Whether a node is an element rather than a comment.
+ */
+declare function isXcschemeElement(node: XcschemeNode): node is XcschemeElement;
+//#endregion
+//#region src/scheme/build.d.ts
+/**
+ * Serializes a scheme document to the text of a `.xcscheme` file.
+ *
+ * @throws XcschemeBuildError for element or attribute names that are not
+ *   XML names and for attribute values carrying unencodable control
+ *   characters, with the path of the offending node.
+ */
+declare function buildXcscheme(document: XcschemeDocument): string;
+//#endregion
+//#region src/scheme/model.d.ts
+/**
+ * Collects elements of the given name anywhere in the tree, in document
+ * order, the subtree root included. Passing no name collects every
+ * element.
+ */
+declare function xcschemeElements(root: XcschemeElement, name?: string): XcschemeElement[];
+/**
+ * A `BuildableReference` element with property-style attribute access.
+ *
+ * Buildable references are the elements editing flows touch most, since
+ * every action points at its target through one. The view reads and
+ * writes the element's attributes directly, so it never goes stale and
+ * needs no separate save step.
+ */
+declare class BuildableReference {
+  /** The underlying element inside the document tree. */
+  readonly element: XcschemeElement;
+  constructor(element: XcschemeElement);
+  /**
+   * The referenced target's object id in the project document, when
+   * present. Xcode repairs a missing or stale identifier on first open.
+   */
+  get blueprintIdentifier(): string | undefined;
+  set blueprintIdentifier(value: string);
+  /**
+   * The referenced target's name, when present.
+   */
+  get blueprintName(): string | undefined;
+  set blueprintName(value: string);
+  /**
+   * The built product's file name, for example `DemoApp.app`, when
+   * present.
+   */
+  get buildableName(): string | undefined;
+  set buildableName(value: string);
+  /**
+   * The container the target lives in, for example
+   * `container:DemoApp.xcodeproj`, when present.
+   */
+  get referencedContainer(): string | undefined;
+  set referencedContainer(value: string);
+}
+/**
+ * A scheme document with typed access to the elements editing flows
+ * touch.
+ *
+ * The model is a thin layer over the node tree. All state lives in the
+ * document itself, and {@link build} serializes whatever the tree
+ * currently says, so typed edits and direct tree edits compose freely.
+ *
+ * ```ts
+ * const scheme = Xcscheme.parse(xcschemeText);
+ * for (const reference of scheme.buildableReferences()) {
+ *   reference.blueprintName = "RenamedApp";
+ *   reference.buildableName = "RenamedApp.app";
+ * }
+ * const text = scheme.build();
+ * ```
+ */
+declare class Xcscheme {
+  /** The underlying parsed document. */
+  readonly document: XcschemeDocument;
+  constructor(document: XcschemeDocument);
+  /**
+   * Parses the text of a `.xcscheme` file into a scheme model.
+   *
+   * @throws XcschemeParseError when the text is not a well-formed scheme
+   *   document, with the line and column of the failure.
+   */
+  static parse(text: string): Xcscheme;
+  /**
+   * Creates the scheme Xcode writes for an application target. See
+   * {@link createXcscheme} for the shape it produces.
+   */
+  static create(options: CreateXcschemeOptions): Xcscheme;
+  /**
+   * The document's `Scheme` element.
+   */
+  get root(): XcschemeElement;
+  /**
+   * Serializes the scheme to the text of a `.xcscheme` file in Xcode's
+   * canonical layout.
+   */
+  build(): string;
+  /**
+   * Collects elements of the given name anywhere in the document, in
+   * document order. Passing no name collects every element.
+   */
+  elements(name?: string): XcschemeElement[];
+  /**
+   * The views of every buildable reference in the document, in document
+   * order. Build entries, testables, macro expansions, runnables, and
+   * action environment buildables all point at their target through one
+   * of these, so rename flows iterate this list.
+   */
+  buildableReferences(): BuildableReference[];
+}
+/**
+ * Options for {@link createXcscheme}.
+ */
+interface CreateXcschemeOptions {
+  /** The application target's name, which also names the scheme. */
+  appName: string;
+  /**
+   * The `.xcodeproj` directory name the buildable references point at.
+   * Defaults to `<appName>.xcodeproj`.
+   */
+  xcodeprojName?: string;
+  /**
+   * The application target's object id in the project document. Xcode
+   * repairs an empty identifier on first open, so omitting it still
+   * produces a working scheme.
+   */
+  blueprintIdentifier?: string;
+}
+/**
+ * Creates the scheme Xcode writes for an application target. The
+ * document carries build, launch, profile, analyze, and archive actions
+ * wired to the app product, with Xcode's default configuration choices
+ * of Debug for development actions and Release for profiling and
+ * archiving.
+ */
+declare function createXcscheme(options: CreateXcschemeOptions): XcschemeDocument;
+//#endregion
+//#region src/scheme/parse.d.ts
+/**
+ * Parses the text of a `.xcscheme` file into its node tree.
+ *
+ * @throws XcschemeParseError when the text is not a well-formed scheme
+ *   document, with the line and column of the failure.
+ */
+declare function parseXcscheme(text: string): XcschemeDocument;
+//#endregion
 //#region src/uuid.d.ts
 /**
  * Deterministic object identifiers for generated pbxproj objects.
@@ -1272,4 +1574,4 @@ declare function parsePbxproj(text: string): PbxprojValue;
  */
 declare function generateObjectId(seed: string, existing: ReadonlySet<string>): string;
 //#endregion
-export { type AddNativeTargetOptions, AggregateTarget, type ApplePlatform, type BuildConfigurationProperties, type BuildFileProperties, BuildPhase, type BuildPhaseProperties, BuildRule, type BuildRuleProperties, type BuildSettings, type ConfigurationListProperties, type ContainerItemProxyProperties, CopyFilesDestination, type ExceptionSetProperties, type FileReferenceProperties, Group, type GroupProperties, Isa, LegacyTarget, type LegacyTargetProperties, NativeTarget, type NativeTargetProperties, type PbxprojArray, PbxprojBuildError, type PbxprojErrorPosition, type PbxprojObject, PbxprojParseError, type PbxprojValue, ProductType, type ProjectIssue, type ProjectIssueKind, ReferenceProxy, type ReferenceProxyProperties, RootProject, type RootProjectProperties, type SwiftPackageProductDependencyProperties, type SwiftPackageReferenceProperties, SyncRootGroup, type SyncRootGroupProperties, Target, type TargetDependencyProperties, type TargetProperties, VersionGroup, type VersionGroupProperties, XcodeModelError, XcodeObject, XcodeProject, buildPbxproj, generateObjectId, parsePbxproj };
+export { type AddNativeTargetOptions, AggregateTarget, type ApplePlatform, BuildConfiguration, type BuildConfigurationProperties, type BuildFileProperties, BuildPhase, type BuildPhaseProperties, BuildRule, type BuildRuleProperties, type BuildSettings, BuildableReference, type ConfigurationListProperties, ContainerItemProxy, type ContainerItemProxyProperties, CopyFilesDestination, type CreateXcschemeOptions, type ExceptionSetProperties, FileReference, type FileReferenceProperties, Group, type GroupProperties, Isa, LegacyTarget, type LegacyTargetProperties, NativeTarget, type NativeTargetProperties, type PbxprojArray, PbxprojBuildError, type PbxprojErrorPosition, type PbxprojObject, PbxprojParseError, type PbxprojValue, ProductType, type ProjectIssue, type ProjectIssueKind, ReferenceProxy, type ReferenceProxyProperties, RootProject, type RootProjectProperties, type SwiftPackageProductDependencyProperties, type SwiftPackageReferenceProperties, SyncRootGroup, type SyncRootGroupProperties, Target, type TargetDependencyProperties, type TargetProperties, VersionGroup, type VersionGroupProperties, XcodeModelError, XcodeObject, XcodeProject, Xcscheme, XcschemeBuildError, type XcschemeComment, type XcschemeDocument, type XcschemeElement, type XcschemeNode, XcschemeParseError, buildPbxproj, buildXcscheme, createXcscheme, generateObjectId, isXcschemeElement, parsePbxproj, parseXcscheme, xcschemeElements };