t3code-cli 0.13.0 → 0.14.0

package/dist/src/auth/error.d.ts

@@ -1,50 +0,0 @@
-import * as Cause from "effect/Cause";
-import * as Schema from "effect/Schema";
-import { PlatformError } from "effect/PlatformError";
-import { ConfigError } from "../config/error.ts";
-import { UrlError } from "../config/url/error.ts";
-declare const AuthPairingUrlError_base: Schema.Class<AuthPairingUrlError, Schema.TaggedStruct<"AuthPairingUrlError", {
-    readonly message: Schema.String;
-    readonly cause: Schema.optionalKey<Schema.instanceOf<Cause.IllegalArgumentError, Cause.IllegalArgumentError>>;
-}>, Cause.YieldableError>;
-export declare class AuthPairingUrlError extends AuthPairingUrlError_base {
-}
-declare const AuthConfigError_base: Schema.Class<AuthConfigError, Schema.TaggedStruct<"AuthConfigError", {
-    readonly message: Schema.String;
-    readonly cause: Schema.optionalKey<Schema.Union<readonly [typeof ConfigError, typeof UrlError]>>;
-}>, Cause.YieldableError>;
-export declare class AuthConfigError extends AuthConfigError_base {
-}
-declare const AuthTransportError_base: Schema.Class<AuthTransportError, Schema.TaggedStruct<"AuthTransportError", {
-    readonly message: Schema.String;
-    readonly cause: Schema.Union<readonly [Schema.Union<readonly [typeof import("@t3tools/contracts").EnvironmentRequestInvalidError, typeof import("@t3tools/contracts").EnvironmentAuthInvalidError, typeof import("@t3tools/contracts").EnvironmentScopeRequiredError, typeof import("@t3tools/contracts").EnvironmentOperationForbiddenError, typeof import("@t3tools/contracts").EnvironmentResourceNotFoundError, typeof import("@t3tools/contracts").EnvironmentInternalError]>, Schema.instanceOf<import("@t3tools/client-runtime/authorization").RemoteEnvironmentAuthFetchError, unknown>, Schema.instanceOf<import("@t3tools/client-runtime/authorization").RemoteEnvironmentAuthInvalidJsonError, unknown>, Schema.instanceOf<import("@t3tools/client-runtime/authorization").RemoteEnvironmentAuthTimeoutError, unknown>, Schema.instanceOf<import("@t3tools/client-runtime/authorization").RemoteEnvironmentAuthUndeclaredStatusError, unknown>]>;
-}>, Cause.YieldableError>;
-export declare class AuthTransportError extends AuthTransportError_base {
-}
-declare const AuthLocalSecretError_base: Schema.Class<AuthLocalSecretError, Schema.TaggedStruct<"AuthLocalSecretError", {
-    readonly message: Schema.String;
-    readonly cause: Schema.optionalKey<Schema.instanceOf<PlatformError, PlatformError>>;
-}>, Cause.YieldableError>;
-export declare class AuthLocalSecretError extends AuthLocalSecretError_base {
-}
-declare const AuthLocalDatabaseError_base: Schema.Class<AuthLocalDatabaseError, Schema.TaggedStruct<"AuthLocalDatabaseError", {
-    readonly operation: Schema.Literals<readonly ["connect", "query", "schema"]>;
-    readonly message: Schema.String;
-}>, Cause.YieldableError>;
-export declare class AuthLocalDatabaseError extends AuthLocalDatabaseError_base {
-}
-declare const AuthLocalSigningError_base: Schema.Class<AuthLocalSigningError, Schema.TaggedStruct<"AuthLocalSigningError", {
-    readonly operation: Schema.Literals<readonly ["sign"]>;
-    readonly message: Schema.String;
-    readonly cause: Schema.optionalKey<Schema.instanceOf<PlatformError, PlatformError>>;
-}>, Cause.YieldableError>;
-export declare class AuthLocalSigningError extends AuthLocalSigningError_base {
-}
-declare const AuthLocalError_base: Schema.Class<AuthLocalError, Schema.TaggedStruct<"AuthLocalError", {
-    readonly message: Schema.String;
-    readonly cause: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.instanceOf<PlatformError, unknown>, Schema.instanceOf<Schema.SchemaError, unknown>, typeof UrlError]>, typeof AuthLocalSecretError, typeof AuthLocalDatabaseError, typeof AuthLocalSigningError]>>;
-}>, Cause.YieldableError>;
-export declare class AuthLocalError extends AuthLocalError_base {
-}
-export type AuthError = AuthPairingUrlError | AuthConfigError | AuthTransportError | AuthLocalError;
-export {};

package/dist/src/auth/index.d.ts

@@ -1,10 +0,0 @@
-export { T3Auth } from "./service.ts";
-export { T3AuthLive, makeT3Auth } from "./layer.ts";
-export { T3LocalAuth, T3LocalAuthLive, makeT3LocalAuth } from "./local.ts";
-export { T3LocalAuthOrigin, T3LocalAuthOriginLive, makeT3LocalAuthOrigin } from "./local-origin.ts";
-export { T3LocalAuthToken, T3LocalAuthTokenLive, makeT3LocalAuthToken } from "./local-token.ts";
-export { T3AuthPairing, T3AuthPairingLive, makeT3AuthPairing, parsePairingUrl } from "./pairing.ts";
-export { AuthConfigError, AuthLocalDatabaseError, AuthLocalError, AuthLocalSecretError, AuthLocalSigningError, AuthPairingUrlError, AuthTransportError, } from "./error.ts";
-export type { AuthError } from "./error.ts";
-export type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
-export type { AuthConfigInput, AuthEnvironmentListItem, AuthEnvironmentSummary, AuthResolvedConfig, AuthSessionRole, AuthStatusResult, AuthUnpairResult, AuthUseResult, LocalAuthInput, LocalAuthOriginInput, LocalAuthResult, LocalAuthTokenInput, LocalAuthTokenResult, PairingUrl, PairResult, PersistEnvironmentInput, } from "./type.ts";

package/dist/src/auth/layer.d.ts

@@ -1,53 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { T3Config } from "../config/config.ts";
-import { AuthConfigError } from "./error.ts";
-import { T3LocalAuth } from "./local.ts";
-import { T3AuthPairing } from "./pairing.ts";
-import { T3Auth } from "./service.ts";
-import { T3AuthTransport } from "./transport.ts";
-import type { AuthConfigInput, AuthEnvironmentListItem, AuthResolvedConfig } from "./type.ts";
-export declare const makeT3Auth: () => Effect.Effect<{
-    pair: (pairingUrl: string) => Effect.Effect<import("./type.ts").PairResult, import("./error.ts").AuthPairingUrlError | import("./error.ts").AuthTransportError>;
-    local: (input: import("./type.ts").LocalAuthInput) => Effect.Effect<import("./type.ts").LocalAuthResult, import("./error.ts").AuthLocalError>;
-    writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthConfigError, never>;
-    persistEnvironment: (input: {
-        readonly name: string;
-        readonly url: string;
-        readonly token: string;
-        readonly local: boolean;
-        readonly replace?: boolean;
-        readonly allowReplace: boolean;
-    }) => Effect.Effect<string, AuthConfigError, never>;
-    environmentExists: (name: string) => Effect.Effect<boolean, AuthConfigError, never>;
-    defaultNameFromUrl: (url: string) => Effect.Effect<string, AuthConfigError, never>;
-    defaultNameForLocal: () => Effect.Effect<"local", never, never>;
-    listEnvironments: () => Effect.Effect<AuthEnvironmentListItem[], AuthConfigError, never>;
-    useEnvironment: (name: string) => Effect.Effect<{
-        name: string;
-        default: true;
-    }, AuthConfigError, never>;
-    resolveUnpairTarget: (input: {
-        readonly name?: string;
-    }) => Effect.Effect<string, AuthConfigError, never>;
-    unpairEnvironment: (input: {
-        readonly name: string;
-    }) => Effect.Effect<{
-        name: string;
-        removed: true;
-    }, AuthConfigError, never>;
-    status: () => Effect.Effect<{
-        readonly config: AuthResolvedConfig;
-        readonly session: {
-            readonly authenticated: boolean;
-            readonly role?: "client" | "owner";
-            readonly sessionMethod?: string;
-            readonly expiresAt?: string;
-        };
-    }, AuthConfigError | import("./error.ts").AuthTransportError, never>;
-    issueWebSocketTicket: () => Effect.Effect<{
-        readonly ticket: string;
-        readonly expiresAt: string;
-    }, AuthConfigError | import("./error.ts").AuthTransportError, never>;
-}, never, T3AuthPairing | T3AuthTransport | T3Config | T3LocalAuth>;
-export declare const T3AuthLive: Layer.Layer<T3Auth, never, T3AuthPairing | T3AuthTransport | T3Config | T3LocalAuth>;

package/dist/src/auth/local-base-dir.d.ts

@@ -1,8 +0,0 @@
-import * as Effect from "effect/Effect";
-import type { CliRuntime } from "../cli/runtime/service.ts";
-import type { T3CliEnvShape } from "../config/env/env.ts";
-export declare const resolveLocalBaseDir: (input: {
-    readonly baseDir?: string | undefined;
-    readonly cliRuntime: CliRuntime["Service"];
-    readonly t3CliEnv: T3CliEnvShape;
-}) => Effect.Effect<string, never, import("effect/Path").Path>;

package/dist/src/auth/local-origin.d.ts

@@ -1,18 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import { CliRuntime } from "../cli/runtime/service.ts";
-import { AuthLocalError } from "./error.ts";
-import type { LocalAuthOriginInput } from "./type.ts";
-declare const T3LocalAuthOrigin_base: Context.ServiceClass<T3LocalAuthOrigin, "t3cli/T3LocalAuthOrigin", {
-    readonly resolve: (input?: LocalAuthOriginInput) => Effect.Effect<string, AuthLocalError>;
-}>;
-export declare class T3LocalAuthOrigin extends T3LocalAuthOrigin_base {
-}
-export declare const makeT3LocalAuthOrigin: () => Effect.Effect<{
-    resolve: (input?: LocalAuthOriginInput | undefined) => Effect.Effect<string, AuthLocalError, never>;
-}, import("effect/Config").ConfigError, CliRuntime | FileSystem.FileSystem | Path.Path>;
-export declare const T3LocalAuthOriginLive: Layer.Layer<T3LocalAuthOrigin, import("effect/Config").ConfigError, CliRuntime | FileSystem.FileSystem | Path.Path>;
-export {};

package/dist/src/auth/local-token.d.ts

@@ -1,26 +0,0 @@
-import * as Context from "effect/Context";
-import * as Crypto from "effect/Crypto";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import { CliRuntime } from "../cli/runtime/service.ts";
-import { SqlClientFactory } from "../sql/service.ts";
-import { AuthLocalError } from "./error.ts";
-import type { LocalAuthTokenInput, LocalAuthTokenResult } from "./type.ts";
-declare const T3LocalAuthToken_base: Context.ServiceClass<T3LocalAuthToken, "t3cli/T3LocalAuthToken", {
-    readonly create: (input: LocalAuthTokenInput) => Effect.Effect<LocalAuthTokenResult, AuthLocalError>;
-}>;
-export declare class T3LocalAuthToken extends T3LocalAuthToken_base {
-}
-export declare const makeT3LocalAuthToken: () => Effect.Effect<{
-    create: (input: LocalAuthTokenInput) => Effect.Effect<{
-        token: string;
-        role: "client" | "owner";
-        expiresAt: string;
-        source: "local";
-        baseDir: string;
-    }, AuthLocalError, never>;
-}, import("effect/Config").ConfigError, CliRuntime | Crypto.Crypto | FileSystem.FileSystem | Path.Path | SqlClientFactory>;
-export declare const T3LocalAuthTokenLive: Layer.Layer<T3LocalAuthToken, import("effect/Config").ConfigError, CliRuntime | Crypto.Crypto | FileSystem.FileSystem | Path.Path | SqlClientFactory>;
-export {};

package/dist/src/auth/local.d.ts

@@ -1,24 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { AuthLocalError } from "./error.ts";
-import { T3LocalAuthOrigin } from "./local-origin.ts";
-import { T3LocalAuthToken } from "./local-token.ts";
-import type { LocalAuthInput, LocalAuthResult } from "./type.ts";
-declare const T3LocalAuth_base: Context.ServiceClass<T3LocalAuth, "t3cli/T3LocalAuth", {
-    readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthLocalError>;
-}>;
-export declare class T3LocalAuth extends T3LocalAuth_base {
-}
-export declare const makeT3LocalAuth: () => Effect.Effect<{
-    local: (input: LocalAuthInput) => Effect.Effect<{
-        url: string;
-        token: string;
-        role: "client" | "owner";
-        expiresAt: string;
-        source: "local";
-        baseDir: string;
-    }, AuthLocalError, never>;
-}, never, T3LocalAuthOrigin | T3LocalAuthToken>;
-export declare const T3LocalAuthLive: Layer.Layer<T3LocalAuth, never, T3LocalAuthOrigin | T3LocalAuthToken>;
-export {};

package/dist/src/auth/pairing.d.ts

@@ -1,22 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { AuthPairingUrlError, AuthTransportError } from "./error.ts";
-import { T3AuthTransport } from "./transport.ts";
-import type { PairingUrl, PairResult } from "./type.ts";
-declare const T3AuthPairing_base: Context.ServiceClass<T3AuthPairing, "t3cli/T3AuthPairing", {
-    readonly pair: (pairingUrl: string) => Effect.Effect<PairResult, AuthPairingUrlError | AuthTransportError>;
-}>;
-export declare class T3AuthPairing extends T3AuthPairing_base {
-}
-export declare const makeT3AuthPairing: () => Effect.Effect<{
-    pair: (pairingUrl: string) => Effect.Effect<{
-        url: string;
-        token: string;
-        role: "client" | "owner";
-        expiresAt: string;
-    }, AuthPairingUrlError | AuthTransportError, never>;
-}, never, T3AuthTransport>;
-export declare const T3AuthPairingLive: Layer.Layer<T3AuthPairing, never, T3AuthTransport>;
-export declare function parsePairingUrl(value: string): Effect.Effect<PairingUrl, AuthPairingUrlError>;
-export {};

package/dist/src/auth/remote-error.d.ts

@@ -1,3 +0,0 @@
-import { RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError } from "@t3tools/client-runtime/authorization";
-import * as Schema from "effect/Schema";
-export declare const RemoteEnvironmentAuthErrorSchema: Schema.Union<readonly [Schema.Union<readonly [typeof import("@t3tools/contracts").EnvironmentRequestInvalidError, typeof import("@t3tools/contracts").EnvironmentAuthInvalidError, typeof import("@t3tools/contracts").EnvironmentScopeRequiredError, typeof import("@t3tools/contracts").EnvironmentOperationForbiddenError, typeof import("@t3tools/contracts").EnvironmentResourceNotFoundError, typeof import("@t3tools/contracts").EnvironmentInternalError]>, Schema.instanceOf<RemoteEnvironmentAuthFetchError, unknown>, Schema.instanceOf<RemoteEnvironmentAuthInvalidJsonError, unknown>, Schema.instanceOf<RemoteEnvironmentAuthTimeoutError, unknown>, Schema.instanceOf<RemoteEnvironmentAuthUndeclaredStatusError, unknown>]>;

package/dist/src/auth/schema.d.ts

@@ -1,58 +0,0 @@
-import * as Schema from "effect/Schema";
-export declare const AuthAccessTokenResultSchema: Schema.Struct<{
-    readonly access_token: Schema.String;
-    readonly issued_token_type: Schema.String;
-    readonly token_type: Schema.Literal<"Bearer">;
-    readonly expires_in: Schema.Number;
-    readonly scope: Schema.String;
-}>;
-export type AuthAccessTokenResult = typeof AuthAccessTokenResultSchema.Type;
-export type AuthBearerBootstrapResult = {
-    readonly authenticated: true;
-    readonly role: "owner" | "client";
-    readonly sessionMethod: "bearer-access-token";
-    readonly expiresAt: string;
-    readonly sessionToken: string;
-};
-export declare const AuthSessionStateSchema: Schema.Struct<{
-    readonly authenticated: Schema.Boolean;
-    readonly role: Schema.optionalKey<Schema.Literals<readonly ["owner", "client"]>>;
-    readonly sessionMethod: Schema.optionalKey<Schema.String>;
-    readonly expiresAt: Schema.optionalKey<Schema.String>;
-}>;
-export type AuthSessionState = typeof AuthSessionStateSchema.Type;
-export declare const AuthWebSocketTicketResultSchema: Schema.Struct<{
-    readonly ticket: Schema.String;
-    readonly expiresAt: Schema.String;
-}>;
-export type AuthWebSocketTicketResult = typeof AuthWebSocketTicketResultSchema.Type;
-export declare const AuthLocalRuntimeStateSchema: Schema.Struct<{
-    readonly version: Schema.Literal<1>;
-    readonly origin: Schema.String;
-}>;
-export type AuthLocalRuntimeState = typeof AuthLocalRuntimeStateSchema.Type;
-export declare const decodeAuthAccessTokenResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
-    readonly access_token: string;
-    readonly issued_token_type: string;
-    readonly token_type: "Bearer";
-    readonly expires_in: number;
-    readonly scope: string;
-}, Schema.SchemaError, never>;
-export declare const decodeAuthSessionState: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
-    readonly authenticated: boolean;
-    readonly role?: "client" | "owner";
-    readonly sessionMethod?: string;
-    readonly expiresAt?: string;
-}, Schema.SchemaError, never>;
-export declare const decodeAuthWebSocketTicketResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
-    readonly ticket: string;
-    readonly expiresAt: string;
-}, Schema.SchemaError, never>;
-export declare const decodeAuthLocalRuntimeState: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
-    readonly version: 1;
-    readonly origin: string;
-}, Schema.SchemaError, never>;
-export declare const decodeAuthLocalRuntimeStateFromJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
-    readonly version: 1;
-    readonly origin: string;
-}, Schema.SchemaError, never>;

package/dist/src/auth/service.d.ts

@@ -1,27 +0,0 @@
-import * as Context from "effect/Context";
-import type * as Effect from "effect/Effect";
-import type { AuthWebSocketTicketResult } from "./schema.ts";
-import type { AuthError } from "./error.ts";
-import type { AuthConfigInput, AuthEnvironmentListItem, AuthStatusResult, AuthUnpairResult, AuthUseResult, LocalAuthInput, LocalAuthResult, PairResult, PersistEnvironmentInput } from "./type.ts";
-declare const T3Auth_base: Context.ServiceClass<T3Auth, "t3cli/T3Auth", {
-    readonly pair: (value: string) => Effect.Effect<PairResult, AuthError>;
-    readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthError>;
-    readonly writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthError>;
-    readonly persistEnvironment: (input: PersistEnvironmentInput) => Effect.Effect<string, AuthError>;
-    readonly environmentExists: (name: string) => Effect.Effect<boolean, AuthError>;
-    readonly defaultNameFromUrl: (url: string) => Effect.Effect<string, AuthError>;
-    readonly defaultNameForLocal: () => Effect.Effect<string, AuthError>;
-    readonly listEnvironments: () => Effect.Effect<readonly AuthEnvironmentListItem[], AuthError>;
-    readonly useEnvironment: (name: string) => Effect.Effect<AuthUseResult, AuthError>;
-    readonly unpairEnvironment: (input: {
-        readonly name: string;
-    }) => Effect.Effect<AuthUnpairResult, AuthError>;
-    readonly resolveUnpairTarget: (input: {
-        readonly name?: string;
-    }) => Effect.Effect<string, AuthError>;
-    readonly status: () => Effect.Effect<AuthStatusResult, AuthError>;
-    readonly issueWebSocketTicket: () => Effect.Effect<AuthWebSocketTicketResult, AuthError>;
-}>;
-export declare class T3Auth extends T3Auth_base {
-}
-export {};

package/dist/src/auth/transport.d.ts

@@ -1,22 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { HttpClient } from "effect/unstable/http";
-import { AuthTransportError } from "./error.ts";
-import { type AuthBearerBootstrapResult, type AuthSessionState, type AuthWebSocketTicketResult } from "./schema.ts";
-export type AuthTransportConnection = {
-    readonly url: string;
-    readonly token: string;
-};
-declare const T3AuthTransport_base: Context.ServiceClass<T3AuthTransport, "t3cli/T3AuthTransport", {
-    readonly bootstrapBearer: (input: {
-        readonly baseUrl: string;
-        readonly credential: string;
-    }) => Effect.Effect<AuthBearerBootstrapResult, AuthTransportError>;
-    readonly getSession: (connection: AuthTransportConnection) => Effect.Effect<AuthSessionState, AuthTransportError>;
-    readonly issueWebSocketTicket: (connection: AuthTransportConnection) => Effect.Effect<AuthWebSocketTicketResult, AuthTransportError>;
-}>;
-export declare class T3AuthTransport extends T3AuthTransport_base {
-}
-export declare const T3AuthTransportLive: Layer.Layer<T3AuthTransport, never, HttpClient.HttpClient>;
-export {};

package/dist/src/auth/type.d.ts

@@ -1,83 +0,0 @@
-import type { AuthBearerBootstrapResult } from "./schema.ts";
-import type { AuthSessionState } from "./schema.ts";
-export type AuthSessionRole = AuthBearerBootstrapResult["role"];
-export type PairingUrl = {
-    readonly baseUrl: string;
-    readonly credential: string;
-};
-export type AuthConfigInput = {
-    readonly name: string;
-    readonly url: string;
-    readonly token: string;
-    readonly local: boolean;
-    readonly makeDefault?: boolean;
-};
-export type PersistEnvironmentInput = {
-    readonly name: string;
-    readonly url: string;
-    readonly token: string;
-    readonly local: boolean;
-    readonly replace?: boolean;
-    readonly allowReplace: boolean;
-};
-export type AuthResolvedConfig = {
-    readonly url: string;
-    readonly token: string;
-    readonly source: "env" | "config";
-    readonly local: boolean;
-    readonly environment?: string;
-};
-export type AuthEnvironmentSummary = {
-    readonly name: string;
-    readonly url: string;
-    readonly local: boolean;
-    readonly default: boolean;
-};
-export type AuthStatusResult = {
-    readonly config: AuthResolvedConfig;
-    readonly session: AuthSessionState;
-};
-export type AuthEnvironmentListItem = AuthEnvironmentSummary & {
-    readonly active: boolean;
-};
-export type PairResult = {
-    readonly url: string;
-    readonly token: string;
-    readonly role: AuthBearerBootstrapResult["role"];
-    readonly expiresAt: string;
-};
-export type LocalAuthInput = {
-    readonly baseDir?: string;
-    readonly origin?: string;
-    readonly role: AuthSessionRole;
-    readonly label: string;
-    readonly subject: string;
-};
-export type LocalAuthTokenInput = Omit<LocalAuthInput, "origin">;
-export type LocalAuthOriginInput = {
-    readonly baseDir?: string;
-    readonly origin?: string;
-};
-export type LocalAuthTokenResult = {
-    readonly token: string;
-    readonly role: AuthSessionRole;
-    readonly expiresAt: string;
-    readonly source: "local";
-    readonly baseDir: string;
-};
-export type LocalAuthResult = {
-    readonly url: string;
-    readonly token: string;
-    readonly role: AuthSessionRole;
-    readonly expiresAt: string;
-    readonly source: "local";
-    readonly baseDir: string;
-};
-export type AuthUseResult = {
-    readonly name: string;
-    readonly default: true;
-};
-export type AuthUnpairResult = {
-    readonly name: string;
-    readonly removed: true;
-};

package/dist/src/cli/env/flag.d.ts

@@ -1,2 +0,0 @@
-import { GlobalFlag } from "effect/unstable/cli";
-export declare const cliEnvironmentSetting: GlobalFlag.Setting<"environment", import("effect/Option").Option<string>>;

package/dist/src/cli/env/index.d.ts

@@ -1,2 +0,0 @@
-export { cliEnvironmentSetting } from "./flag.ts";
-export * as Selection from "./selection-layer.ts";

package/dist/src/cli/env/selection-layer.d.ts

@@ -1,3 +0,0 @@
-import * as Layer from "effect/Layer";
-import { T3ConfigSelection } from "../../config/selection/service.ts";
-export declare const layer: Layer.Layer<T3ConfigSelection, import("effect/Config").ConfigError, never>;

package/dist/src/cli/flags.d.ts

@@ -1,20 +0,0 @@
-import { Flag } from "effect/unstable/cli";
-export declare const projectFlag: Flag.Flag<import("effect/Option").Option<string>>;
-export declare const threadFlag: Flag.Flag<import("effect/Option").Option<string>>;
-export declare const worktreeFlag: Flag.Flag<import("effect/Option").Option<string>>;
-export declare const projectPathFlag: Flag.Flag<string>;
-export declare const yesFlag: Flag.Flag<boolean>;
-export declare const replaceFlag: Flag.Flag<boolean>;
-export declare const envNameFlag: Flag.Flag<import("effect/Option").Option<string>>;
-export declare const forceFlag: Flag.Flag<boolean>;
-export declare const selfActionForceFlag: Flag.Flag<boolean>;
-export declare const formatFlag: Flag.Flag<"auto" | "human" | "json">;
-export declare const threadFormatFlag: Flag.Flag<"auto" | "human" | "json" | "ndjson">;
-export declare const waitFormatFlag: Flag.Flag<"auto" | "human" | "ndjson">;
-export declare const modelFlags: {
-    readonly option: Flag.Flag<import("effect/Option").Option<Record<string, string>>>;
-    readonly reasoningEffort: Flag.Flag<import("effect/Option").Option<string>>;
-    readonly effort: Flag.Flag<import("effect/Option").Option<string>>;
-    readonly fastMode: Flag.Flag<import("effect/Option").Option<boolean>>;
-    readonly thinking: Flag.Flag<import("effect/Option").Option<boolean>>;
-};

package/dist/src/cli/format/index.d.ts

@@ -1 +0,0 @@
-export { resolveOutputFormat, canRenderLiveTerminal, isInteractiveHumanTerminal, isAgentEnvironment, humanJsonFormatChoices, humanNdjsonFormatChoices, humanJsonNdjsonFormatChoices, type HumanJsonFormat, type HumanNdjsonFormat, type HumanJsonNdjsonFormat, } from "./output.ts";

package/dist/src/cli/format/output.d.ts

@@ -1,12 +0,0 @@
-import type { T3CliEnvShape } from "../../config/env/env.ts";
-import type { CliRuntime } from "../runtime/service.ts";
-export declare const humanJsonFormatChoices: readonly ["auto", "human", "json"];
-export declare const humanNdjsonFormatChoices: readonly ["auto", "human", "ndjson"];
-export declare const humanJsonNdjsonFormatChoices: readonly ["auto", "human", "json", "ndjson"];
-export type HumanJsonFormat = (typeof humanJsonFormatChoices)[number];
-export type HumanNdjsonFormat = (typeof humanNdjsonFormatChoices)[number];
-export type HumanJsonNdjsonFormat = (typeof humanJsonNdjsonFormatChoices)[number];
-export declare function resolveOutputFormat<T extends "json" | "ndjson">(format: "auto" | "human" | T, cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape, nonHumanFormat: T): "human" | T;
-export declare function canRenderLiveTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape): boolean;
-export declare function isInteractiveHumanTerminal(cliRuntime: CliRuntime["Service"], t3CliEnv: T3CliEnvShape): boolean;
-export declare function isAgentEnvironment(t3CliEnv: T3CliEnvShape): boolean;

package/dist/src/cli/index.d.ts

@@ -1,5 +0,0 @@
-export { formatFlag, modelFlags, projectFlag, projectPathFlag, threadFlag, threadFormatFlag, waitFormatFlag, worktreeFlag, } from "./flags.ts";
-export * as Env from "./env/index.ts";
-export * as Runtime from "./runtime/index.ts";
-export { resolveCommandProjectRef, resolveProjectRef, resolveThreadId, resolveWorktreePath, } from "./scope/index.ts";
-export { resolveOutputFormat, canRenderLiveTerminal, isInteractiveHumanTerminal, isAgentEnvironment, humanJsonFormatChoices, humanNdjsonFormatChoices, humanJsonNdjsonFormatChoices, type HumanJsonFormat, type HumanNdjsonFormat, type HumanJsonNdjsonFormat, } from "./format/index.ts";

package/dist/src/cli/runtime/index.d.ts

@@ -1 +0,0 @@
-export { CliRuntime, layer } from "./service.ts";

package/dist/src/cli/runtime/service.d.ts

@@ -1,16 +0,0 @@
-import * as Context from "effect/Context";
-import * as Layer from "effect/Layer";
-declare const CliRuntime_base: Context.ServiceClass<CliRuntime, "t3cli/CliRuntime", {
-    readonly cwd: string;
-    readonly stdoutIsTTY: boolean;
-    readonly stderrIsTTY: boolean;
-}>;
-export declare class CliRuntime extends CliRuntime_base {
-    static layerTest: (input?: {
-        readonly cwd?: string;
-        readonly stdoutIsTTY?: boolean;
-        readonly stderrIsTTY?: boolean;
-    }) => Layer.Layer<CliRuntime, never, never>;
-}
-export declare const layer: Layer.Layer<CliRuntime, never, never>;
-export {};

package/dist/src/cli/scope/index.d.ts

@@ -1 +0,0 @@
-export { resolveCommandProjectRef, resolveProjectRef, resolveThreadId, resolveWorktreePath, } from "./resolve.ts";

package/dist/src/cli/scope/resolve.d.ts

@@ -1,20 +0,0 @@
-import type { T3CliEnvScope } from "../../config/env/env.ts";
-export declare function resolveProjectRef(input: {
-    readonly value: string | undefined;
-    readonly scope: T3CliEnvScope;
-}): string | undefined;
-export declare function resolveCommandProjectRef(input: {
-    readonly value: string | undefined;
-    readonly scope: T3CliEnvScope;
-    readonly cwd: string;
-    readonly isLocal?: boolean;
-}): string | undefined;
-export declare function resolveWorktreePath(input: {
-    readonly value: string | undefined;
-    readonly scope: T3CliEnvScope;
-    readonly inferred?: string;
-}): string | undefined;
-export declare function resolveThreadId(input: {
-    readonly value: string | undefined;
-    readonly scope: T3CliEnvScope;
-}): string | undefined;

package/dist/src/cli-path/layer.d.ts

@@ -1,3 +0,0 @@
-import * as Layer from "effect/Layer";
-import { CliPath } from "./service.ts";
-export declare const NodeCliPathLayer: Layer.Layer<CliPath, never, never>;

package/dist/src/cli-path/service.d.ts

@@ -1,8 +0,0 @@
-import * as Context from "effect/Context";
-export type CliPathShape = {
-    readonly path: string;
-};
-declare const CliPath_base: Context.ServiceClass<CliPath, "t3cli/CliPath", CliPathShape>;
-export declare class CliPath extends CliPath_base {
-}
-export {};

package/dist/src/config/config.d.ts

@@ -1,49 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import { T3CredentialCrypto } from "./credential/service.ts";
-import { ConfigError } from "./error.ts";
-import { T3ConfigSelection } from "./selection/service.ts";
-import type { EnvironmentSummary, ResolvedConfig, UpsertEnvironmentInput } from "./types.ts";
-declare const T3Config_base: Context.ServiceClass<T3Config, "t3cli/T3Config", {
-    readonly resolve: () => Effect.Effect<ResolvedConfig, ConfigError>;
-    readonly resolveActiveEnvironmentName: () => Effect.Effect<string | undefined, ConfigError>;
-    readonly listEnvironments: () => Effect.Effect<readonly EnvironmentSummary[], ConfigError>;
-    readonly upsertEnvironment: (input: UpsertEnvironmentInput) => Effect.Effect<void, ConfigError>;
-    readonly setDefaultEnvironment: (name: string) => Effect.Effect<void, ConfigError>;
-    readonly removeEnvironment: (name: string) => Effect.Effect<void, ConfigError>;
-    readonly hasEnvironment: (name: string) => Effect.Effect<boolean, ConfigError>;
-    readonly getDefaultEnvironmentName: () => Effect.Effect<string | undefined, ConfigError>;
-}>;
-export declare class T3Config extends T3Config_base {
-}
-export declare const make: () => Effect.Effect<{
-    readonly resolve: () => Effect.Effect<{
-        url: string;
-        token: string;
-        source: "env";
-        local: false;
-    } | {
-        url: string;
-        token: string;
-        source: "config";
-        local: boolean;
-        environment: string;
-    }, ConfigError, never>;
-    readonly resolveActiveEnvironmentName: () => Effect.Effect<string | undefined, ConfigError, never>;
-    readonly listEnvironments: () => Effect.Effect<{
-        name: string;
-        url: string;
-        local: boolean;
-        default: boolean;
-    }[], ConfigError, never>;
-    readonly upsertEnvironment: (input: UpsertEnvironmentInput) => Effect.Effect<void, ConfigError, never>;
-    readonly setDefaultEnvironment: (name: string) => Effect.Effect<void, ConfigError, never>;
-    readonly removeEnvironment: (name: string) => Effect.Effect<void, ConfigError, never>;
-    readonly hasEnvironment: (name: string) => Effect.Effect<boolean, ConfigError, never>;
-    readonly getDefaultEnvironmentName: () => Effect.Effect<string | undefined, ConfigError, never>;
-}, import("effect/Config").ConfigError, FileSystem.FileSystem | Path.Path | T3ConfigSelection | T3CredentialCrypto>;
-export declare const layer: Layer.Layer<T3Config, import("effect/Config").ConfigError, FileSystem.FileSystem | Path.Path | T3ConfigSelection | T3CredentialCrypto>;
-export {};

package/dist/src/config/credential/cipher-node.d.ts

@@ -1,3 +0,0 @@
-import * as Layer from "effect/Layer";
-import { T3CredentialCipher } from "./cipher.ts";
-export declare const layerNode: Layer.Layer<T3CredentialCipher, never, never>;

package/dist/src/config/credential/cipher-web.d.ts

@@ -1,3 +0,0 @@
-import * as Layer from "effect/Layer";
-import { T3CredentialCipher } from "./cipher.ts";
-export declare const layerWeb: Layer.Layer<T3CredentialCipher, never, never>;

package/dist/src/config/credential/cipher.d.ts

@@ -1,29 +0,0 @@
-import * as Context from "effect/Context";
-import type * as Effect from "effect/Effect";
-import type { CredentialCipherError } from "./error.ts";
-export declare const credentialCipherNonceByteLength = 12;
-export declare const credentialCipherTagByteLength = 16;
-export type AesGcmEncryptInput = {
-    readonly key: Uint8Array;
-    readonly nonce: Uint8Array;
-    readonly plaintext: Uint8Array;
-    readonly additionalData: Uint8Array;
-};
-export type AesGcmDecryptInput = {
-    readonly key: Uint8Array;
-    readonly nonce: Uint8Array;
-    readonly ciphertext: Uint8Array;
-    readonly tag: Uint8Array;
-    readonly additionalData: Uint8Array;
-};
-export type AesGcmEncryptResult = {
-    readonly ciphertext: Uint8Array;
-    readonly tag: Uint8Array;
-};
-declare const T3CredentialCipher_base: Context.ServiceClass<T3CredentialCipher, "t3cli/T3CredentialCipher", {
-    readonly encrypt: (input: AesGcmEncryptInput) => Effect.Effect<AesGcmEncryptResult, CredentialCipherError>;
-    readonly decrypt: (input: AesGcmDecryptInput) => Effect.Effect<Uint8Array, CredentialCipherError>;
-}>;
-export declare class T3CredentialCipher extends T3CredentialCipher_base {
-}
-export {};