rdx-cli 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,969 @@
+import { Effect, Option, Schema } from "effect";
+import { Command } from "@effect/cli";
+import * as effect_Types0 from "effect/Types";
+import * as effect_Cause0 from "effect/Cause";
+
+//#region src/schemas.d.ts
+declare const PLACEHOLDER_PUBLIC_KEY_HEX = "<replace-with-ed25519-public-key-hex>";
+declare const PLACEHOLDER_SIGNATURE_HEX = "<replace-with-ed25519-signature-hex>";
+declare const NetworkSchema: Schema.brand<Schema.Literal<["mainnet", "stokenet"]>, "Network">;
+type Network = typeof NetworkSchema.Type;
+declare const ArtifactScopeSchema: Schema.brand<Schema.Literal<["local", "global"]>, "ArtifactScope">;
+type ArtifactScope = typeof ArtifactScopeSchema.Type;
+declare const OutputFormatSchema: Schema.brand<Schema.Literal<["json", "text"]>, "OutputFormat">;
+declare const HexStringSchema: Schema.filter<typeof Schema.String>;
+declare const Ed25519PublicKeyHexSchema: Schema.filter<Schema.filter<typeof Schema.String>>;
+declare const Ed25519SignatureHexSchema: Schema.filter<Schema.filter<typeof Schema.String>>;
+declare const SubintentIdSchema: Schema.filter<typeof Schema.String>;
+declare const PublicKeySchema: Schema.Struct<{
+  curve: Schema.Literal<["Ed25519"]>;
+  hex: Schema.filter<Schema.filter<typeof Schema.String>>;
+}>;
+declare const SigningScopeSchema: Schema.Union<[Schema.Struct<{
+  kind: Schema.Literal<["rootIntent"]>;
+}>, Schema.Struct<{
+  kind: Schema.Literal<["subintent"]>;
+  subintentId: Schema.filter<typeof Schema.String>;
+}>, Schema.Struct<{
+  kind: Schema.Literal<["notarySignatory"]>;
+}>, Schema.Struct<{
+  kind: Schema.Literal<["notary"]>;
+}>]>;
+declare const SigningRequestSchema: Schema.Struct<{
+  type: Schema.Literal<["signingRequest"]>;
+  version: Schema.Literal<[1]>;
+  transactionId: typeof Schema.NonEmptyString;
+  scope: Schema.Union<[Schema.Struct<{
+    kind: Schema.Literal<["rootIntent"]>;
+  }>, Schema.Struct<{
+    kind: Schema.Literal<["subintent"]>;
+    subintentId: Schema.filter<typeof Schema.String>;
+  }>, Schema.Struct<{
+    kind: Schema.Literal<["notarySignatory"]>;
+  }>, Schema.Struct<{
+    kind: Schema.Literal<["notary"]>;
+  }>]>;
+  account: Schema.NullOr<typeof Schema.NonEmptyString>;
+  hash: Schema.Struct<{
+    id: Schema.NullOr<typeof Schema.String>;
+    hex: Schema.filter<typeof Schema.String>;
+  }>;
+  signingRequestPath: Schema.optional<typeof Schema.String>;
+}>;
+declare const SignatureTemplateSchema: Schema.Struct<{
+  type: Schema.Literal<["signatureTemplate"]>;
+  version: Schema.Literal<[1]>;
+  transactionId: typeof Schema.NonEmptyString;
+  scope: Schema.Union<[Schema.Struct<{
+    kind: Schema.Literal<["rootIntent"]>;
+  }>, Schema.Struct<{
+    kind: Schema.Literal<["subintent"]>;
+    subintentId: Schema.filter<typeof Schema.String>;
+  }>, Schema.Struct<{
+    kind: Schema.Literal<["notarySignatory"]>;
+  }>, Schema.Struct<{
+    kind: Schema.Literal<["notary"]>;
+  }>]>;
+  account: Schema.NullOr<typeof Schema.NonEmptyString>;
+  hash: Schema.Struct<{
+    id: Schema.NullOr<typeof Schema.String>;
+    hex: Schema.filter<typeof Schema.String>;
+  }>;
+  signingRequestPath: Schema.optional<typeof Schema.String>;
+  publicKey: Schema.Struct<{
+    curve: Schema.Literal<["Ed25519"]>;
+    hex: Schema.Union<[Schema.filter<Schema.filter<typeof Schema.String>>, Schema.Literal<["<replace-with-ed25519-public-key-hex>"]>]>;
+  }>;
+  signature: Schema.Struct<{
+    curve: Schema.Literal<["Ed25519"]>;
+    hex: Schema.Union<[Schema.filter<Schema.filter<typeof Schema.String>>, Schema.Literal<["<replace-with-ed25519-signature-hex>"]>]>;
+  }>;
+}>;
+declare const SignatureEntrySchema: Schema.Struct<{
+  scope: Schema.Union<[Schema.Struct<{
+    kind: Schema.Literal<["rootIntent"]>;
+  }>, Schema.Struct<{
+    kind: Schema.Literal<["subintent"]>;
+    subintentId: Schema.filter<typeof Schema.String>;
+  }>, Schema.Struct<{
+    kind: Schema.Literal<["notarySignatory"]>;
+  }>, Schema.Struct<{
+    kind: Schema.Literal<["notary"]>;
+  }>]>;
+  account: Schema.NullOr<typeof Schema.NonEmptyString>;
+  hash: Schema.Struct<{
+    id: Schema.NullOr<typeof Schema.String>;
+    hex: Schema.filter<typeof Schema.String>;
+  }>;
+  signingRequestPath: Schema.optional<typeof Schema.String>;
+  publicKey: Schema.filter<Schema.Struct<{
+    curve: Schema.Literal<["Ed25519"]>;
+    hex: Schema.filter<Schema.filter<typeof Schema.String>>;
+  }>>;
+  signature: Schema.filter<Schema.Struct<{
+    curve: Schema.Literal<["Ed25519"]>;
+    hex: Schema.filter<Schema.filter<typeof Schema.String>>;
+  }>>;
+}>;
+declare const SignatureFileSchema: Schema.Struct<{
+  type: Schema.Literal<["signatureFile"]>;
+  version: Schema.Literal<[1]>;
+  transactionId: typeof Schema.NonEmptyString;
+  signatures: Schema.Array$<Schema.Struct<{
+    scope: Schema.Union<[Schema.Struct<{
+      kind: Schema.Literal<["rootIntent"]>;
+    }>, Schema.Struct<{
+      kind: Schema.Literal<["subintent"]>;
+      subintentId: Schema.filter<typeof Schema.String>;
+    }>, Schema.Struct<{
+      kind: Schema.Literal<["notarySignatory"]>;
+    }>, Schema.Struct<{
+      kind: Schema.Literal<["notary"]>;
+    }>]>;
+    account: Schema.NullOr<typeof Schema.NonEmptyString>;
+    hash: Schema.Struct<{
+      id: Schema.NullOr<typeof Schema.String>;
+      hex: Schema.filter<typeof Schema.String>;
+    }>;
+    signingRequestPath: Schema.optional<typeof Schema.String>;
+    publicKey: Schema.filter<Schema.Struct<{
+      curve: Schema.Literal<["Ed25519"]>;
+      hex: Schema.filter<Schema.filter<typeof Schema.String>>;
+    }>>;
+    signature: Schema.filter<Schema.Struct<{
+      curve: Schema.Literal<["Ed25519"]>;
+      hex: Schema.filter<Schema.filter<typeof Schema.String>>;
+    }>>;
+  }>>;
+}>;
+declare const BatchSignatureFileSchema: Schema.Struct<{
+  type: Schema.Literal<["batchSignatureFile"]>;
+  version: Schema.Literal<[1]>;
+  signatures: Schema.NonEmptyArray<Schema.Struct<{
+    type: Schema.Literal<["signatureFile"]>;
+    version: Schema.Literal<[1]>;
+    transactionId: typeof Schema.NonEmptyString;
+    signatures: Schema.Array$<Schema.Struct<{
+      scope: Schema.Union<[Schema.Struct<{
+        kind: Schema.Literal<["rootIntent"]>;
+      }>, Schema.Struct<{
+        kind: Schema.Literal<["subintent"]>;
+        subintentId: Schema.filter<typeof Schema.String>;
+      }>, Schema.Struct<{
+        kind: Schema.Literal<["notarySignatory"]>;
+      }>, Schema.Struct<{
+        kind: Schema.Literal<["notary"]>;
+      }>]>;
+      account: Schema.NullOr<typeof Schema.NonEmptyString>;
+      hash: Schema.Struct<{
+        id: Schema.NullOr<typeof Schema.String>;
+        hex: Schema.filter<typeof Schema.String>;
+      }>;
+      signingRequestPath: Schema.optional<typeof Schema.String>;
+      publicKey: Schema.filter<Schema.Struct<{
+        curve: Schema.Literal<["Ed25519"]>;
+        hex: Schema.filter<Schema.filter<typeof Schema.String>>;
+      }>>;
+      signature: Schema.filter<Schema.Struct<{
+        curve: Schema.Literal<["Ed25519"]>;
+        hex: Schema.filter<Schema.filter<typeof Schema.String>>;
+      }>>;
+    }>>;
+  }>>;
+}>;
+declare const SubintentsFileSchema: Schema.Struct<{
+  type: Schema.Literal<["subintents"]>;
+  version: Schema.Literal<[1]>;
+  subintents: Schema.filter<Schema.Record$<typeof Schema.String, Schema.Struct<{
+    manifest: typeof Schema.NonEmptyString;
+  }>>>;
+}>;
+declare const NotaryFileSchema: Schema.Struct<{
+  type: Schema.Literal<["notary"]>;
+  version: Schema.Literal<[1]>;
+  publicKey: Schema.Struct<{
+    curve: Schema.Literal<["Ed25519"]>;
+    hex: Schema.filter<Schema.filter<typeof Schema.String>>;
+  }>;
+  notaryIsSignatory: Schema.optional<typeof Schema.Boolean>;
+}>;
+declare const ArtifactStatusSchema: Schema.Union<[Schema.Literal<["prepared"]>, Schema.Literal<["notarized"]>, Schema.Literal<["submitted"]>]>;
+declare const AuthorizationAnalysisSchema: Schema.Struct<{
+  rootIntent: Schema.Array$<typeof Schema.String>;
+  subintents: Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>;
+}>;
+declare const PreparedTransactionSchema: Schema.Struct<{
+  type: Schema.Literal<["preparedTransaction"]>;
+  version: Schema.Literal<[1]>;
+  transactionId: typeof Schema.NonEmptyString;
+  network: Schema.brand<Schema.Literal<["mainnet", "stokenet"]>, "Network">;
+  intentHash: Schema.Struct<{
+    id: Schema.NullOr<typeof Schema.String>;
+    hex: Schema.filter<typeof Schema.String>;
+  }>;
+  manifestSourceFile: typeof Schema.String;
+  transactionIntentPath: typeof Schema.String;
+  staticAnalysisPath: typeof Schema.String;
+  signingRequests: Schema.Array$<typeof Schema.String>;
+  signatureTemplates: Schema.Array$<typeof Schema.String>;
+  subintentOrder: Schema.Array$<typeof Schema.String>;
+  authorizationAnalysis: Schema.Struct<{
+    rootIntent: Schema.Array$<typeof Schema.String>;
+    subintents: Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>;
+  }>;
+  notaryPublicKey: Schema.optional<Schema.Struct<{
+    curve: Schema.Literal<["Ed25519"]>;
+    hex: Schema.filter<Schema.filter<typeof Schema.String>>;
+  }>>;
+  notaryIsSignatory: Schema.optional<typeof Schema.Boolean>;
+}>;
+declare const NetworkTransactionStatusSchema: Schema.Struct<{
+  transactionId: typeof Schema.NonEmptyString;
+  status: typeof Schema.String;
+  statusDescription: typeof Schema.String;
+  errorMessage: Schema.NullOr<typeof Schema.String>;
+  checkedAt: typeof Schema.String;
+}>;
+declare const SubmitResultSchema: Schema.Struct<{
+  type: Schema.Literal<["submitResult"]>;
+  version: Schema.Literal<[1]>;
+  transactionId: typeof Schema.NonEmptyString;
+  networkStatus: Schema.Struct<{
+    transactionId: typeof Schema.NonEmptyString;
+    status: typeof Schema.String;
+    statusDescription: typeof Schema.String;
+    errorMessage: Schema.NullOr<typeof Schema.String>;
+    checkedAt: typeof Schema.String;
+  }>;
+  attempts: Schema.Array$<Schema.Struct<{
+    checkedAt: typeof Schema.String;
+    status: typeof Schema.String;
+    statusDescription: typeof Schema.String;
+    errorMessage: Schema.NullOr<typeof Schema.String>;
+  }>>;
+}>;
+declare const AccountFungiblesResultSchema: Schema.Struct<{
+  type: Schema.Literal<["commandResult"]>;
+  command: Schema.Literal<["account fungibles"]>;
+  result: typeof Schema.Unknown;
+}>;
+declare const AccountNftsResultSchema: Schema.Struct<{
+  type: Schema.Literal<["commandResult"]>;
+  command: Schema.Literal<["account nfts"]>;
+  result: typeof Schema.Unknown;
+}>;
+declare const AccountShowResultSchema: Schema.Struct<{
+  type: Schema.Literal<["commandResult"]>;
+  command: Schema.Literal<["account show"]>;
+  result: typeof Schema.Unknown;
+}>;
+declare const TransactionHistoryResultSchema: Schema.Struct<{
+  type: Schema.Literal<["commandResult"]>;
+  command: Schema.Literal<["tx history"]>;
+  result: typeof Schema.Unknown;
+}>;
+declare const VirtualAccountDerivationSchema: Schema.Struct<{
+  network: Schema.brand<Schema.Literal<["mainnet", "stokenet"]>, "Network">;
+  derivation: Schema.Literal<["virtualAccount"]>;
+  publicKey: Schema.Struct<{
+    curve: Schema.Literal<["Ed25519"]>;
+    hex: Schema.filter<Schema.filter<typeof Schema.String>>;
+  }>;
+  accountAddress: typeof Schema.String;
+}>;
+type SigningScope = typeof SigningScopeSchema.Type;
+type SigningRequest = typeof SigningRequestSchema.Type;
+type SignatureTemplate = typeof SignatureTemplateSchema.Type;
+type SignatureEntry = typeof SignatureEntrySchema.Type;
+type SignatureFile = typeof SignatureFileSchema.Type;
+type SubintentsFile = typeof SubintentsFileSchema.Type;
+type NotaryFile = typeof NotaryFileSchema.Type;
+type ArtifactStatus = typeof ArtifactStatusSchema.Type;
+type AuthorizationAnalysis = typeof AuthorizationAnalysisSchema.Type;
+type PreparedTransaction = typeof PreparedTransactionSchema.Type;
+type NetworkTransactionStatus = typeof NetworkTransactionStatusSchema.Type;
+type SubmitResult = typeof SubmitResultSchema.Type;
+type AccountFungiblesResult = typeof AccountFungiblesResultSchema.Type;
+type AccountNftsResult = typeof AccountNftsResultSchema.Type;
+type AccountShowResult = typeof AccountShowResultSchema.Type;
+type TransactionHistoryResult = typeof TransactionHistoryResultSchema.Type;
+type VirtualAccountDerivation = typeof VirtualAccountDerivationSchema.Type;
+//#endregion
+//#region src/config.d.ts
+declare const RdxConfigFileSchema: Schema.Struct<{
+  network: Schema.optional<Schema.brand<Schema.Literal<["mainnet", "stokenet"]>, "Network">>;
+  gatewayBaseUrl: Schema.optional<typeof Schema.String>;
+  artifactScope: Schema.optional<Schema.brand<Schema.Literal<["local", "global"]>, "ArtifactScope">>;
+  artifactDirectory: Schema.optional<typeof Schema.String>;
+  notary: Schema.optional<Schema.Struct<{
+    publicKey: Schema.Struct<{
+      curve: Schema.Literal<["Ed25519"]>;
+      hex: Schema.filter<Schema.filter<typeof Schema.String>>;
+    }>;
+    notaryIsSignatory: Schema.optional<typeof Schema.Boolean>;
+  }>>;
+}>;
+type RdxConfigFile = typeof RdxConfigFileSchema.Type;
+declare const ResolvedRdxConfigSchema: Schema.Struct<{
+  network: Schema.brand<Schema.Literal<["mainnet", "stokenet"]>, "Network">;
+  gatewayBaseUrl: Schema.optional<typeof Schema.String>;
+  artifactScope: Schema.brand<Schema.Literal<["local", "global"]>, "ArtifactScope">;
+  artifactDirectory: Schema.optional<typeof Schema.String>;
+  artifactRoot: typeof Schema.String;
+  notary: Schema.optional<Schema.Struct<{
+    publicKey: Schema.Struct<{
+      curve: Schema.Literal<["Ed25519"]>;
+      hex: Schema.filter<Schema.filter<typeof Schema.String>>;
+    }>;
+    notaryIsSignatory: Schema.optional<typeof Schema.Boolean>;
+  }>>;
+  projectConfigPath: Schema.optional<typeof Schema.String>;
+  globalConfigPath: Schema.optional<typeof Schema.String>;
+}>;
+type ResolvedRdxConfig = typeof ResolvedRdxConfigSchema.Type;
+declare const ConfigResolutionError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "ConfigResolutionError";
+} & Readonly<A>;
+declare class ConfigResolutionError extends ConfigResolutionError_base<{
+  path: string;
+  reason: unknown;
+}> {}
+declare const resolveRdxConfig: (input: {
+  cwd: string;
+  home?: string;
+  overrides?: RdxConfigFile;
+}) => Effect.Effect<ResolvedRdxConfig, ConfigResolutionError>;
+declare const ConfigResolver_base: Effect.Service.Class<ConfigResolver, "ConfigResolver", {
+  readonly sync: () => {
+    resolve: (input: {
+      cwd: string;
+      home?: string;
+      overrides?: RdxConfigFile;
+    }) => Effect.Effect<ResolvedRdxConfig, ConfigResolutionError>;
+  };
+}>;
+declare class ConfigResolver extends ConfigResolver_base {}
+//#endregion
+//#region src/accountReads.d.ts
+declare const AccountReadError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "AccountReadError";
+} & Readonly<A>;
+declare class AccountReadError extends AccountReadError_base<{
+  accountAddress: string;
+  reason: unknown;
+}> {}
+declare const InvalidPublicKeyError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "InvalidPublicKeyError";
+} & Readonly<A>;
+declare class InvalidPublicKeyError extends InvalidPublicKeyError_base<{
+  code: 'INVALID_PUBLIC_KEY';
+  publicKeyHex: string;
+}> {}
+declare const getAccountFungibles: (input: {
+  accountAddress: string;
+  readFungibles: (accountAddress: string) => Effect.Effect<unknown, unknown>;
+}) => Effect.Effect<AccountFungiblesResult, unknown>;
+declare const getAccountNfts: (input: {
+  accountAddress: string;
+  readNfts: (accountAddress: string) => Effect.Effect<unknown, unknown>;
+}) => Effect.Effect<AccountNftsResult, unknown>;
+declare const gatewayAccountFungibles: (input: {
+  config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+  accountAddress: string;
+}) => Effect.Effect<unknown, AccountReadError>;
+declare const gatewayAccountNfts: (input: {
+  config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+  accountAddress: string;
+}) => Effect.Effect<unknown, AccountReadError>;
+declare const gatewayAccountDetails: (input: {
+  config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+  accountAddress: string;
+}) => Effect.Effect<unknown, AccountReadError>;
+declare const gatewayAccountHistory: (input: {
+  config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+  accountAddress: string;
+  limit: number;
+}) => Effect.Effect<unknown, AccountReadError>;
+declare const getAccountDetails: (input: {
+  accountAddress: string;
+  readDetails: (accountAddress: string) => Effect.Effect<unknown, unknown>;
+}) => Effect.Effect<AccountShowResult, unknown>;
+declare const getAccountTransactionHistory: (input: {
+  accountAddress: string;
+  limit: number;
+  readHistory: (accountAddress: string, limit: number) => Effect.Effect<unknown, unknown>;
+}) => Effect.Effect<TransactionHistoryResult, unknown>;
+declare const deriveVirtualAccountAddress: (input: {
+  network: Network;
+  publicKeyHex: string;
+}) => Effect.Effect<{
+  type: "commandResult";
+  command: "account derive";
+} & VirtualAccountDerivation, unknown>;
+declare const AccountReadService_base: Effect.Service.Class<AccountReadService, "AccountReadService", {
+  readonly sync: () => {
+    getAccountDetails: (input: {
+      accountAddress: string;
+      readDetails: (accountAddress: string) => Effect.Effect<unknown, unknown>;
+    }) => Effect.Effect<AccountShowResult, unknown>;
+    getAccountFungibles: (input: {
+      accountAddress: string;
+      readFungibles: (accountAddress: string) => Effect.Effect<unknown, unknown>;
+    }) => Effect.Effect<AccountFungiblesResult, unknown>;
+    getAccountNfts: (input: {
+      accountAddress: string;
+      readNfts: (accountAddress: string) => Effect.Effect<unknown, unknown>;
+    }) => Effect.Effect<AccountNftsResult, unknown>;
+    getAccountTransactionHistory: (input: {
+      accountAddress: string;
+      limit: number;
+      readHistory: (accountAddress: string, limit: number) => Effect.Effect<unknown, unknown>;
+    }) => Effect.Effect<TransactionHistoryResult, unknown>;
+    deriveVirtualAccountAddress: (input: {
+      network: Network;
+      publicKeyHex: string;
+    }) => Effect.Effect<{
+      type: "commandResult";
+      command: "account derive";
+    } & VirtualAccountDerivation, unknown>;
+    gatewayAccountDetails: (input: {
+      config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+      accountAddress: string;
+    }) => Effect.Effect<unknown, AccountReadError>;
+    gatewayAccountFungibles: (input: {
+      config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+      accountAddress: string;
+    }) => Effect.Effect<unknown, AccountReadError>;
+    gatewayAccountHistory: (input: {
+      config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+      accountAddress: string;
+      limit: number;
+    }) => Effect.Effect<unknown, AccountReadError>;
+    gatewayAccountNfts: (input: {
+      config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+      accountAddress: string;
+    }) => Effect.Effect<unknown, AccountReadError>;
+  };
+}>;
+declare class AccountReadService extends AccountReadService_base {}
+//#endregion
+//#region src/artifacts.d.ts
+declare const ArtifactStoreError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "ArtifactStoreError";
+} & Readonly<A>;
+declare class ArtifactStoreError extends ArtifactStoreError_base<{
+  path: string;
+  reason: unknown;
+}> {}
+type SignatureImportResult = {
+  signatureFile: SignatureFile;
+  acceptedCount: number;
+  warnings: string[];
+};
+type TransactionArtifactSummary = {
+  transactionId: string;
+  path: string;
+  network: PreparedTransaction['network'];
+  status: ArtifactStatus;
+  intentHash: string;
+  manifestSourceFile: string;
+  networkStatus?: NetworkTransactionStatus;
+  updatedSubmitResultPath?: string | null;
+};
+declare const normalizeSignatures: (input: {
+  transactionId: string;
+  existing: readonly SignatureEntry[];
+  imported: readonly SignatureEntry[];
+}) => SignatureImportResult;
+declare const createTransactionArtifactDirectory: (input: {
+  artifactRoot: string;
+  transactionId: string;
+}) => Effect.Effect<string, ArtifactStoreError>;
+declare const writeCanonicalSignatures: (input: {
+  artifactPath: string;
+  transactionId: string;
+  existing: readonly SignatureEntry[];
+  imported: readonly SignatureEntry[];
+}) => Effect.Effect<string, ArtifactStoreError>;
+declare const writeSubmitResult: (input: {
+  artifactPath: string;
+  submitResult: SubmitResult;
+}) => Effect.Effect<string, ArtifactStoreError>;
+declare const findTransactionArtifact: (input: {
+  artifactRoot: string;
+  transactionId: string;
+}) => Effect.Effect<string, ArtifactStoreError>;
+declare const findTransactionArtifactOption: (input: {
+  artifactRoot: string;
+  transactionId: string;
+}) => Effect.Effect<string | undefined>;
+declare const listTransactionArtifacts: (input: {
+  artifactRoot: string;
+  pattern?: string;
+  regex?: string;
+  network?: PreparedTransaction["network"];
+  status?: ArtifactStatus;
+}) => Effect.Effect<TransactionArtifactSummary[], ArtifactStoreError>;
+declare const ArtifactStore_base: Effect.Service.Class<ArtifactStore, "ArtifactStore", {
+  readonly sync: () => {
+    createTransactionArtifactDirectory: (input: {
+      artifactRoot: string;
+      transactionId: string;
+    }) => Effect.Effect<string, ArtifactStoreError>;
+    findTransactionArtifactOption: (input: {
+      artifactRoot: string;
+      transactionId: string;
+    }) => Effect.Effect<string | undefined>;
+    findTransactionArtifact: (input: {
+      artifactRoot: string;
+      transactionId: string;
+    }) => Effect.Effect<string, ArtifactStoreError>;
+    listTransactionArtifacts: (input: {
+      artifactRoot: string;
+      pattern?: string;
+      regex?: string;
+      network?: PreparedTransaction["network"];
+      status?: ArtifactStatus;
+    }) => Effect.Effect<TransactionArtifactSummary[], ArtifactStoreError>;
+    writeSubmitResult: (input: {
+      artifactPath: string;
+      submitResult: SubmitResult;
+    }) => Effect.Effect<string, ArtifactStoreError>;
+    writeCanonicalSignatures: (input: {
+      artifactPath: string;
+      transactionId: string;
+      existing: readonly SignatureEntry[];
+      imported: readonly SignatureEntry[];
+    }) => Effect.Effect<string, ArtifactStoreError>;
+  };
+}>;
+declare class ArtifactStore extends ArtifactStore_base {}
+//#endregion
+//#region src/addSignatures.d.ts
+type AddSignaturesResult = SignatureImportResult & {
+  signaturesPath: string;
+  complete: boolean;
+};
+declare const addSignaturesToArtifact: (input: {
+  artifactRoot: string;
+  transactionId: string;
+  signatureFilePaths: string[];
+}) => Effect.Effect<AddSignaturesResult, unknown>;
+declare const AddSignaturesWorkflow_base: Effect.Service.Class<AddSignaturesWorkflow, "AddSignaturesWorkflow", {
+  readonly sync: () => {
+    addSignaturesToArtifact: (input: {
+      artifactRoot: string;
+      transactionId: string;
+      signatureFilePaths: string[];
+    }) => Effect.Effect<AddSignaturesResult, unknown>;
+  };
+}>;
+declare class AddSignaturesWorkflow extends AddSignaturesWorkflow_base {}
+//#endregion
+//#region src/notarize.d.ts
+declare const NotarizeError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "NotarizeError";
+} & Readonly<A>;
+declare class NotarizeError extends NotarizeError_base<{
+  code: 'INCOMPLETE_SIGNATURES' | 'MISSING_SIGNATURE_FILE' | 'MISSING_NOTARY_PUBLIC_KEY' | 'PREVIEW_FAILED' | 'READ_FAILED' | 'WRITE_FAILED';
+  path?: string;
+  reason?: unknown;
+}> {}
+type NotarizeTransactionResult = {
+  transactionId: string;
+  artifactPath: string;
+  signedTransactionIntentPath: string;
+  notarySigningRequestPath: string;
+  notarySignatureTemplatePath: string;
+};
+declare const gatewayNotarizePreview: (input: {
+  config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+  previewTransactionHex: string;
+}) => Effect.Effect<void, NotarizeError, never>;
+declare const notarizeTransactionArtifact: (input: {
+  artifactRoot: string;
+  transactionId: string;
+  previewSignedTransactionIntent?: (previewTransactionHex: string) => Effect.Effect<void, unknown>;
+}) => Effect.Effect<NotarizeTransactionResult, unknown>;
+declare const NotarizationCoordinator_base: Effect.Service.Class<NotarizationCoordinator, "NotarizationCoordinator", {
+  readonly sync: () => {
+    notarizeTransactionArtifact: (input: {
+      artifactRoot: string;
+      transactionId: string;
+      previewSignedTransactionIntent?: (previewTransactionHex: string) => Effect.Effect<void, unknown>;
+    }) => Effect.Effect<NotarizeTransactionResult, unknown>;
+    gatewayNotarizePreview: (input: {
+      config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+      previewTransactionHex: string;
+    }) => Effect.Effect<void, NotarizeError, never>;
+  };
+}>;
+declare class NotarizationCoordinator extends NotarizationCoordinator_base {}
+//#endregion
+//#region src/prepare.d.ts
+type PrepareTransactionResult = {
+  transactionId: string;
+  artifactPath: string;
+  preparedPath: string;
+  transactionIntentPath: string;
+  staticAnalysisPath: string;
+  signatureTemplatePaths: string[];
+  startEpochInclusive: number;
+  endEpochExclusive: number;
+};
+declare const PreparePreviewError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "PreparePreviewError";
+} & Readonly<A>;
+declare class PreparePreviewError extends PreparePreviewError_base<{
+  message?: string;
+  reason?: unknown;
+}> {}
+declare const gatewayPreparePreview: (input: {
+  config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+  previewTransactionHex: string;
+}) => Effect.Effect<void, PreparePreviewError, never>;
+declare const gatewayCurrentEpoch: (input: {
+  config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+}) => Effect.Effect<number, PreparePreviewError, never>;
+declare const prepareTransactionArtifacts: (input: {
+  artifactRoot: string;
+  network: Network;
+  manifestPath: string;
+  subintentsPath?: string;
+  notary: Pick<NotaryFile, "publicKey" | "notaryIsSignatory">;
+  currentEpoch?: number;
+  previewPreparedTransaction?: (previewTransactionHex: string) => Effect.Effect<void, unknown>;
+}) => Effect.Effect<PrepareTransactionResult, unknown>;
+declare const TransactionPreparer_base: Effect.Service.Class<TransactionPreparer, "TransactionPreparer", {
+  readonly sync: () => {
+    prepareTransactionArtifacts: (input: {
+      artifactRoot: string;
+      network: Network;
+      manifestPath: string;
+      subintentsPath?: string;
+      notary: Pick<NotaryFile, "publicKey" | "notaryIsSignatory">;
+      currentEpoch?: number;
+      previewPreparedTransaction?: (previewTransactionHex: string) => Effect.Effect<void, unknown>;
+    }) => Effect.Effect<PrepareTransactionResult, unknown>;
+    gatewayPreparePreview: (input: {
+      config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+      previewTransactionHex: string;
+    }) => Effect.Effect<void, PreparePreviewError, never>;
+    gatewayCurrentEpoch: (input: {
+      config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+    }) => Effect.Effect<number, PreparePreviewError, never>;
+  };
+}>;
+declare class TransactionPreparer extends TransactionPreparer_base {}
+//#endregion
+//#region src/status.d.ts
+declare const TransactionStatusError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "TransactionStatusError";
+} & Readonly<A>;
+declare class TransactionStatusError extends TransactionStatusError_base<{
+  transactionId: string;
+  reason: unknown;
+}> {}
+type TransactionStatusResult = {
+  transactionId: string;
+  artifactPath: string | null;
+  networkStatus: NetworkTransactionStatus;
+  updatedSubmitResultPath: string | null;
+};
+declare const gatewayTransactionStatus: (input: {
+  config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+  transactionId: string;
+}) => Effect.Effect<NetworkTransactionStatus, TransactionStatusError>;
+declare const queryTransactionStatus: (input: {
+  artifactRoot: string;
+  transactionId: string;
+  readOnly?: boolean;
+  getNetworkStatus: (transactionId: string) => Effect.Effect<NetworkTransactionStatus, unknown>;
+}) => Effect.Effect<TransactionStatusResult, unknown>;
+declare const listTransactionArtifactsWithNetworkStatus: (input: {
+  artifactRoot: string;
+  pattern?: string;
+  regex?: string;
+  network?: PreparedTransaction["network"];
+  status?: ArtifactStatus;
+  update?: boolean;
+  getNetworkStatus: (transactionId: string) => Effect.Effect<NetworkTransactionStatus, unknown>;
+}) => Effect.Effect<TransactionArtifactSummary[], unknown>;
+declare const StatusLifecycle_base: Effect.Service.Class<StatusLifecycle, "StatusLifecycle", {
+  readonly sync: () => {
+    queryTransactionStatus: (input: {
+      artifactRoot: string;
+      transactionId: string;
+      readOnly?: boolean;
+      getNetworkStatus: (transactionId: string) => Effect.Effect<NetworkTransactionStatus, unknown>;
+    }) => Effect.Effect<TransactionStatusResult, unknown>;
+    listTransactionArtifactsWithNetworkStatus: (input: {
+      artifactRoot: string;
+      pattern?: string;
+      regex?: string;
+      network?: PreparedTransaction["network"];
+      status?: ArtifactStatus;
+      update?: boolean;
+      getNetworkStatus: (transactionId: string) => Effect.Effect<NetworkTransactionStatus, unknown>;
+    }) => Effect.Effect<TransactionArtifactSummary[], unknown>;
+    gatewayTransactionStatus: (input: {
+      config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+      transactionId: string;
+    }) => Effect.Effect<NetworkTransactionStatus, TransactionStatusError>;
+  };
+}>;
+declare class StatusLifecycle extends StatusLifecycle_base {}
+//#endregion
+//#region src/submit.d.ts
+declare const SubmitError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "SubmitError";
+} & Readonly<A>;
+declare class SubmitError extends SubmitError_base<{
+  code: 'ALREADY_SUBMITTED' | 'MISSING_SIGNATURE' | 'MISSING_NOTARY_SIGNATURE' | 'READ_FAILED' | 'WRITE_FAILED';
+  path?: string;
+  reason?: unknown;
+}> {}
+type SubmitTransactionResult = {
+  transactionId: string;
+  artifactPath: string;
+  notarizedTransactionPath: string;
+  submitResultPath: string;
+  networkStatus: typeof NetworkTransactionStatusSchema.Type;
+};
+declare const gatewaySubmitNotarizedTransaction: (input: {
+  config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+  transactionId: string;
+  notarizedTransactionHex: string;
+}) => Effect.Effect<{
+  readonly transactionId: string;
+  readonly status: string;
+  readonly statusDescription: string;
+  readonly errorMessage: string | null;
+  readonly checkedAt: string;
+}, SubmitError, never>;
+declare const submitTransactionArtifact: (input: {
+  artifactRoot: string;
+  transactionId: string;
+  submitNotarizedTransaction: (notarizedTransactionHex: string) => Effect.Effect<typeof NetworkTransactionStatusSchema.Type, unknown>;
+  pollTransactionStatus?: (transactionId: string) => Effect.Effect<typeof NetworkTransactionStatusSchema.Type, unknown>;
+}) => Effect.Effect<SubmitTransactionResult, unknown>;
+declare const SubmitLifecycle_base: Effect.Service.Class<SubmitLifecycle, "SubmitLifecycle", {
+  readonly sync: () => {
+    submitTransactionArtifact: (input: {
+      artifactRoot: string;
+      transactionId: string;
+      submitNotarizedTransaction: (notarizedTransactionHex: string) => Effect.Effect<typeof NetworkTransactionStatusSchema.Type, unknown>;
+      pollTransactionStatus?: (transactionId: string) => Effect.Effect<typeof NetworkTransactionStatusSchema.Type, unknown>;
+    }) => Effect.Effect<SubmitTransactionResult, unknown>;
+    gatewaySubmitNotarizedTransaction: (input: {
+      config: Pick<ResolvedRdxConfig, "network" | "gatewayBaseUrl">;
+      transactionId: string;
+      notarizedTransactionHex: string;
+    }) => Effect.Effect<{
+      readonly transactionId: string;
+      readonly status: string;
+      readonly statusDescription: string;
+      readonly errorMessage: string | null;
+      readonly checkedAt: string;
+    }, SubmitError, never>;
+  };
+}>;
+declare class SubmitLifecycle extends SubmitLifecycle_base {}
+//#endregion
+//#region src/templates.d.ts
+type TemplateKind = 'subintents' | 'signing-request' | 'signature-template' | 'signature-file';
+declare const workflowTemplate: (kind: TemplateKind) => {
+  type: string;
+  version: number;
+  subintents: {
+    child_one: {
+      manifest: string;
+    };
+  };
+  transactionId?: undefined;
+  scope?: undefined;
+  account?: undefined;
+  hash?: undefined;
+  signingRequestPath?: undefined;
+  publicKey?: undefined;
+  signature?: undefined;
+  signatures?: undefined;
+} | {
+  type: "signingRequest";
+  version: 1;
+  transactionId: string;
+  scope: {
+    kind: "rootIntent";
+  };
+  account: string;
+  hash: {
+    id: string;
+    hex: string;
+  };
+  signingRequestPath: string;
+  subintents?: undefined;
+  publicKey?: undefined;
+  signature?: undefined;
+  signatures?: undefined;
+} | {
+  type: "signatureTemplate";
+  version: 1;
+  transactionId: string;
+  scope: {
+    kind: "rootIntent";
+  };
+  account: string;
+  hash: {
+    id: string;
+    hex: string;
+  };
+  signingRequestPath: string;
+  publicKey: {
+    curve: "Ed25519";
+    hex: string;
+  };
+  signature: {
+    curve: "Ed25519";
+    hex: string;
+  };
+  subintents?: undefined;
+  signatures?: undefined;
+} | {
+  type: "signatureFile";
+  version: 1;
+  transactionId: string;
+  signatures: never[];
+  subintents?: undefined;
+  scope?: undefined;
+  account?: undefined;
+  hash?: undefined;
+  signingRequestPath?: undefined;
+  publicKey?: undefined;
+  signature?: undefined;
+};
+//#endregion
+//#region src/json.d.ts
+type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+  readonly [key: string]: JsonValue;
+};
+declare const JsonValueSchema: Schema.Schema<JsonValue>;
+declare const toJsonValue: (value: unknown) => JsonValue;
+declare const renderJson: (value: unknown) => string;
+//#endregion
+//#region src/cli.d.ts
+type OutputFormat = 'json' | 'text';
+//#endregion
+//#region src/llm.d.ts
+declare const llmGuide = "# rdx Agent Guide\n\nUse `rdx` to prepare, inspect, sign-orchestrate, notarize, submit, and track Radix Transaction Manifest V2 workflows from files. It is built for agents: workflow commands are non-interactive and print JSON by default.\n\n## Core Rules\n\n- Run `rdx config show` before `tx prepare` to verify the resolved network and artifact root.\n- After `tx prepare`, check `startEpochInclusive` and `endEpochExclusive` in the command JSON before collecting signatures.\n- `rdx` defaults to Mainnet. Prepare on the intended network; do not reuse prepared artifacts across networks.\n- A transaction lifecycle is network-bound from `tx prepare` through signing, notarization, submission, and status.\n- `rdx` never stores, accepts, or derives private keys.\n- Participants sign only the requested `hash.hex` outside `rdx` and return a filled signature template or signature file.\n- v1 CLI workflow files support Ed25519 only. Secp256k1 and other curves are rejected.\n- Use `rdx account derive --public-key <hex>` to derive a virtual account address offline from an Ed25519 public key.\n- Do not edit signing request files. Fill signature templates or create signature files instead.\n- Do not rerun `tx prepare` expecting overwrite. Existing transaction artifact directories are protected.\n- Do not submit until intent, subintent, notary-signatory, and notary signatures required by the artifacts are complete.\n- Use `tx path` and `tx list` before manually scanning artifact directories.\n\n## Discover Live Inputs\n\n```sh\nrdx config show\nrdx template print subintents\nrdx template print signing-request\nrdx template print signature-template\nrdx template print signature-file\nrdx --help\nrdx tx prepare --help\n```\n\nUse template output for workflow file shapes. Do not rely on copied config schemas; use `rdx config show` for resolved configuration.\n\n## Transaction Lifecycle\n\n1. Prepare: compile the root manifest plus optional direct child subintents, preview, and write immutable transaction artifacts.\n2. Inspect: read command JSON output, `prepared.json`, copied manifests, signing requests, and templates.\n3. Intent signing: each participant signs the relevant request `hash.hex` out of band.\n4. Import signatures: use `tx add-signatures` one or more times. Imports are normalized into `signatures.json`.\n5. Notarize: after intent/subintent signatures are locally complete, `tx notarize` previews the signed intent and creates the notary signing request.\n6. Notary signing: the notary signs the notary request `hash.hex` out of band.\n7. Import notary signature: use `tx add-signatures` again.\n8. Submit: `tx submit` compiles from prepared artifacts plus canonical signatures, writes the submitted payload, broadcasts, polls, and records the result.\n9. Track: use `tx status`, `tx path`, and `tx list` to inspect local and Gateway state.\n\n## Stable Artifact Mental Model\n\nUse command JSON outputs for exact paths. Common artifact files include:\n\n- `prepared.json`: canonical prepared metadata and signing request/template path index.\n- `transactionIntent.json`: encoded Transaction Intent V2 used by later commands.\n- `staticAnalysis.json`: full static analysis output.\n- `rootManifest.rtm`: copied root manifest.\n- `subintents/<subintentId>.rtm`: copied direct child subintent manifests.\n- `signatures.json`: canonical normalized signature state.\n- `notarizedTransaction.hex`: exact submitted payload.\n- `submitResult.json`: submit attempts and network status results.\n\n## Single-party Example\n\n```sh\nrdx config show\nrdx template print signature-file\nrdx tx prepare --manifest ./tx/root.rtm --notary-file ./tx/notary.json\nrdx tx path txid_example\nrdx tx add-signatures txid_example --file ./tx/signatures/intent-signature.json\nrdx tx notarize txid_example\nrdx tx add-signatures txid_example --file ./tx/signatures/notary-signature.json\nrdx tx submit txid_example\nrdx tx status txid_example\n```\n\nAfter `tx prepare`, inspect the JSON result for `transactionId`, `artifactPath`, `preparedPath`, `startEpochInclusive`, `endEpochExclusive`, and generated `signatureTemplatePaths`. Fill the generated templates by replacing placeholder Ed25519 public key and signature values. Sign only each request's `hash.hex`.\n\n## Multi-party And Subintent Example\n\n```sh\nrdx config show\nrdx template print subintents\nrdx tx prepare --manifest ./tx/root.rtm --subintents ./tx/subintents.json --notary-file ./tx/notary.json\nrdx tx add-signatures txid_example --file ./party-a/root-signature.json\nrdx tx add-signatures txid_example --file ./party-b/child-one-signature.json\nrdx tx add-signatures txid_example --file ./party-c/batch-signatures.json\nrdx tx notarize txid_example\nrdx tx add-signatures txid_example --file ./notary/notary-signature.json\nrdx tx submit txid_example\n```\n\nSubintent IDs in `subintents.json` are also Radix `NamedIntent` values referenced by root `YIELD_TO_CHILD` instructions. v1 supports root plus direct child subintents only. Multiple parties can return signatures asynchronously; repeat `tx add-signatures` until local completeness allows `tx notarize` and later `tx submit`.\n\n## Command Examples\n\n```sh\nrdx config show\nrdx account derive --public-key 1111111111111111111111111111111111111111111111111111111111111111\nrdx account show account_rdx1...\nrdx account fungibles account_rdx1...\nrdx account nfts account_rdx1...\nrdx tx history account_rdx1... --limit 10\nrdx tx prepare --manifest ./tx/root.rtm --notary-file ./tx/notary.json\nrdx tx prepare --manifest ./tx/root.rtm --subintents ./tx/subintents.json --notary-file ./tx/notary.json\nrdx tx add-signatures txid_example --file ./signature.json\nrdx tx add-signatures txid_example --file ./signature-a.json --file ./signature-batch.json\nrdx tx notarize txid_example\nrdx tx submit txid_example\nrdx tx status txid_example\nrdx tx status txid_example --read-only\nrdx tx path txid_example\nrdx tx list\nrdx tx list --pattern root.rtm\nrdx tx list --regex '^txid_' --network mainnet --status prepared\nrdx tx list --with-network-status\nrdx tx list --with-network-status --update-network-status\nrdx template print subintents\nrdx template print signing-request\nrdx template print signature-template\nrdx template print signature-file\n```\n\n`account derive` uses the resolved config network and does not query Gateway. It returns the derived virtual account address, not proof that the account exists on-ledger.\n\n## Troubleshooting\n\n- Workflow command failures print structured JSON errors with `type`, `code`, and `message`.\n- Gateway failures include response details in `message` when the Gateway returns a structured error body.\n- Inspect `code` and `message` first; avoid parsing human help text.\n- Use `rdx tx status`, `rdx tx list`, and `rdx tx path` before reading files manually.\n- If the network is wrong, prepare a new transaction for the intended network.\n- If a placeholder public key or signature remains in a file, replace it with a real Ed25519 value produced outside `rdx`.\n";
+//#endregion
+//#region src/signatureImport.d.ts
+declare const SignatureImportError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "SignatureImportError";
+} & Readonly<A>;
+declare class SignatureImportError extends SignatureImportError_base<{
+  code: 'INVALID_SIGNATURE_FILE' | 'UNKNOWN_SIGNING_REQUEST' | 'PLACEHOLDER_VALUE' | 'INVALID_SIGNATURE';
+  reason: unknown;
+}> {}
+type ImportableSignatureFile = SignatureFile | SignatureTemplate | unknown;
+declare const importSignatures: (input: {
+  transactionId: string;
+  generatedRequests: SigningRequest[];
+  existing: readonly SignatureEntry[];
+  files: ImportableSignatureFile[];
+}) => Effect.Effect<SignatureImportResult, SignatureImportError>;
+declare const SignatureImporter_base: Effect.Service.Class<SignatureImporter, "SignatureImporter", {
+  readonly sync: () => {
+    importSignatures: (input: {
+      transactionId: string;
+      generatedRequests: SigningRequest[];
+      existing: readonly SignatureEntry[];
+      files: ImportableSignatureFile[];
+    }) => Effect.Effect<SignatureImportResult, SignatureImportError>;
+  };
+}>;
+declare class SignatureImporter extends SignatureImporter_base {}
+//#endregion
+//#region src/signingRequests.d.ts
+type SigningRequestHash = {
+  id: string | null;
+  hex: string;
+};
+type AuthorizationRequirements = {
+  rootIntent: string[];
+  subintents: Record<string, string[]>;
+};
+type GeneratedWorkflowFile<File> = {
+  path: string;
+  file: File;
+};
+type GeneratedSigningRequests = {
+  requests: GeneratedWorkflowFile<SigningRequest>[];
+  templates: GeneratedWorkflowFile<SignatureTemplate>[];
+};
+declare const generateSigningRequests: (input: {
+  transactionId: string;
+  rootIntentHash: SigningRequestHash;
+  subintentHashes: Record<string, SigningRequestHash>;
+  authorizationAnalysis: AuthorizationRequirements;
+  notary: {
+    publicKey: SignatureTemplate["publicKey"];
+    notaryIsSignatory: boolean;
+  };
+}) => Effect.Effect<GeneratedSigningRequests>;
+declare const SigningRequestGenerator_base: Effect.Service.Class<SigningRequestGenerator, "SigningRequestGenerator", {
+  readonly sync: () => {
+    generateSigningRequests: (input: {
+      transactionId: string;
+      rootIntentHash: SigningRequestHash;
+      subintentHashes: Record<string, SigningRequestHash>;
+      authorizationAnalysis: AuthorizationRequirements;
+      notary: {
+        publicKey: SignatureTemplate["publicKey"];
+        notaryIsSignatory: boolean;
+      };
+    }) => Effect.Effect<GeneratedSigningRequests>;
+  };
+}>;
+declare class SigningRequestGenerator extends SigningRequestGenerator_base {}
+//#endregion
+//#region src/subintentAssembly.d.ts
+declare const SubintentAssemblyError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "SubintentAssemblyError";
+} & Readonly<A>;
+declare class SubintentAssemblyError extends SubintentAssemblyError_base<{
+  code: 'INVALID_SUBINTENT_ID' | 'MISSING_SUBINTENT' | 'UNREFERENCED_SUBINTENT';
+  subintentId: string;
+}> {}
+type AssembledRootManifest = {
+  rootManifest: string;
+  subintentOrder: string[];
+};
+declare const assembleRootManifest: (input: {
+  rootManifest: string;
+  childIntentHashes: Record<string, string>;
+}) => Effect.Effect<AssembledRootManifest, SubintentAssemblyError>;
+declare const SubintentAssembly_base: Effect.Service.Class<SubintentAssembly, "SubintentAssembly", {
+  readonly sync: () => {
+    assembleRootManifest: (input: {
+      rootManifest: string;
+      childIntentHashes: Record<string, string>;
+    }) => Effect.Effect<AssembledRootManifest, SubintentAssemblyError>;
+  };
+}>;
+declare class SubintentAssembly extends SubintentAssembly_base {}
+//#endregion
+//#region src/index.d.ts
+type RdxResult = {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+};
+type RunRdxInput = {
+  argv: string[];
+  cwd: string;
+};
+declare const runRdxEffect: (input: RunRdxInput) => Effect.Effect<RdxResult>;
+declare const runRdx: (input: RunRdxInput) => Promise<RdxResult>;
+//#endregion
+export { AccountFungiblesResult, AccountFungiblesResultSchema, AccountNftsResult, AccountNftsResultSchema, AccountReadError, AccountReadService, AccountShowResult, AccountShowResultSchema, AddSignaturesResult, AddSignaturesWorkflow, type ArtifactScope, ArtifactScopeSchema, ArtifactStatus, ArtifactStatusSchema, ArtifactStore, ArtifactStoreError, AssembledRootManifest, AuthorizationAnalysis, AuthorizationAnalysisSchema, AuthorizationRequirements, BatchSignatureFileSchema, ConfigResolutionError, ConfigResolver, Ed25519PublicKeyHexSchema, Ed25519SignatureHexSchema, GeneratedSigningRequests, GeneratedWorkflowFile, HexStringSchema, InvalidPublicKeyError, JsonValue, JsonValueSchema, type Network, NetworkSchema, NetworkTransactionStatus, NetworkTransactionStatusSchema, NotarizationCoordinator, NotarizeError, NotarizeTransactionResult, NotaryFile, NotaryFileSchema, type OutputFormat, OutputFormatSchema, PLACEHOLDER_PUBLIC_KEY_HEX, PLACEHOLDER_SIGNATURE_HEX, PreparePreviewError, PrepareTransactionResult, PreparedTransaction, PreparedTransactionSchema, PublicKeySchema, RdxConfigFile, RdxConfigFileSchema, RdxResult, ResolvedRdxConfig, ResolvedRdxConfigSchema, RunRdxInput, SignatureEntry, SignatureEntrySchema, SignatureFile, SignatureFileSchema, SignatureImportError, SignatureImportResult, SignatureImporter, SignatureTemplate, SignatureTemplateSchema, SigningRequest, SigningRequestGenerator, SigningRequestHash, SigningRequestSchema, SigningScope, SigningScopeSchema, StatusLifecycle, SubintentAssembly, SubintentAssemblyError, SubintentIdSchema, SubintentsFile, SubintentsFileSchema, SubmitError, SubmitLifecycle, SubmitResult, SubmitResultSchema, SubmitTransactionResult, TemplateKind, TransactionArtifactSummary, TransactionHistoryResult, TransactionHistoryResultSchema, TransactionPreparer, TransactionStatusError, TransactionStatusResult, type VirtualAccountDerivation, VirtualAccountDerivationSchema, addSignaturesToArtifact, assembleRootManifest, createTransactionArtifactDirectory, deriveVirtualAccountAddress, findTransactionArtifact, findTransactionArtifactOption, gatewayAccountDetails, gatewayAccountFungibles, gatewayAccountHistory, gatewayAccountNfts, gatewayCurrentEpoch, gatewayNotarizePreview, gatewayPreparePreview, gatewaySubmitNotarizedTransaction, gatewayTransactionStatus, generateSigningRequests, getAccountDetails, getAccountFungibles, getAccountNfts, getAccountTransactionHistory, importSignatures, listTransactionArtifacts, listTransactionArtifactsWithNetworkStatus, llmGuide, normalizeSignatures, notarizeTransactionArtifact, prepareTransactionArtifacts, queryTransactionStatus, renderJson, resolveRdxConfig, runRdx, runRdxEffect, submitTransactionArtifact, toJsonValue, workflowTemplate, writeCanonicalSignatures, writeSubmitResult };
+//# sourceMappingURL=index.d.ts.map