import { Context, Crypto, Effect, Layer, Option, Redacted, Schema } from "effect";
/** @experimental */
export declare const issuer = "https://auth.openai.com";
/** @experimental */
export declare const clientId = "app_EMoamEEZ73f0CkXaXp7hrann";
/** @experimental */
export declare const redirectUri = "http://localhost:1455/auth/callback";
/** @experimental */
export declare const scopes = "openid profile email offline_access api.connectors.read api.connectors.invoke";
/** @experimental */
export declare const originator = "codex_cli_rs";
/** @experimental */
export declare const deviceVerificationUrl = "https://auth.openai.com/codex/device";
/** @experimental */
export declare const deviceExchangeRedirect = "https://auth.openai.com/deviceauth/callback";
/** @experimental */
export declare const credentialFormatVersion = 1;
declare const AuthError_base: Schema.Class<AuthError, Schema.TaggedStruct<"@batonfx/providers/OpenAiAccountAuthError", {
    readonly kind: Schema.Literals<readonly ["cancelled", "timeout", "host", "network", "protocol", "account-mismatch", "login-required"]>;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class AuthError extends AuthError_base {
}
declare const StoreError_base: Schema.Class<StoreError, Schema.TaggedStruct<"@batonfx/providers/OpenAiAccountAuthStoreError", {
    readonly kind: Schema.Literals<readonly ["missing", "corrupt", "unsafe", "busy", "io"]>;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class StoreError extends StoreError_base {
}
/** @experimental */
export type Error = AuthError | StoreError;
/** @experimental */
export interface AuthorizationResult {
    readonly code: Redacted.Redacted<string>;
    readonly state: Redacted.Redacted<string>;
}
/** @experimental */
export interface HostInterface {
    readonly authorize: (url: URL, expectedState: Redacted.Redacted<string>) => Effect.Effect<AuthorizationResult, AuthError>;
}
declare const OpenAiAccountAuthHost_base: Context.ServiceClass<OpenAiAccountAuthHost, "@batonfx/providers/provider/openai-account-auth/OpenAiAccountAuthHost", HostInterface>;
/** @experimental */
export declare class OpenAiAccountAuthHost extends OpenAiAccountAuthHost_base {
}
/** @experimental */
export interface DevicePrompt {
    readonly verificationUrl: string;
    readonly userCode: string;
    readonly warning: string;
}
/** @experimental */
export interface PresenterInterface {
    readonly device: (prompt: DevicePrompt) => Effect.Effect<void, AuthError>;
}
declare const OpenAiAccountDevicePresenter_base: Context.ServiceClass<OpenAiAccountDevicePresenter, "@batonfx/providers/provider/openai-account-auth/OpenAiAccountDevicePresenter", PresenterInterface>;
/** @experimental */
export declare class OpenAiAccountDevicePresenter extends OpenAiAccountDevicePresenter_base {
}
/** @experimental */
export declare const TokenResponse: Schema.Struct<{
    readonly access_token: Schema.optionalKey<Schema.String>;
    readonly id_token: Schema.optionalKey<Schema.String>;
    readonly refresh_token: Schema.optionalKey<Schema.String>;
    readonly expires_in: Schema.optionalKey<Schema.Int>;
}>;
/** @experimental */
export type TokenResponse = typeof TokenResponse.Type;
/** @experimental */
export declare const DeviceStartResponse: Schema.Struct<{
    readonly device_auth_id: Schema.String;
    readonly user_code: Schema.String;
    readonly interval: Schema.String;
}>;
/** @experimental */
export declare const DevicePollResponse: Schema.Struct<{
    readonly authorization_code: Schema.String;
    readonly code_challenge: Schema.String;
    readonly code_verifier: Schema.String;
}>;
/** @experimental */
export interface HttpInterface {
    readonly exchange: (input: {
        readonly code: Redacted.Redacted<string>;
        readonly verifier: Redacted.Redacted<string>;
        readonly redirectUri: string;
    }) => Effect.Effect<TokenResponse, AuthError>;
    readonly refresh: (refreshToken: Redacted.Redacted<string>) => Effect.Effect<TokenResponse, AuthError>;
    readonly deviceStart: Effect.Effect<typeof DeviceStartResponse.Type, AuthError>;
    readonly devicePoll: (deviceAuthId: Redacted.Redacted<string>, userCode: string) => Effect.Effect<Option.Option<typeof DevicePollResponse.Type>, AuthError>;
}
declare const OpenAiAccountAuthHttp_base: Context.ServiceClass<OpenAiAccountAuthHttp, "@batonfx/providers/provider/openai-account-auth/OpenAiAccountAuthHttp", HttpInterface>;
/** @experimental */
export declare class OpenAiAccountAuthHttp extends OpenAiAccountAuthHttp_base {
}
/** @experimental */
export declare const CredentialDisk: Schema.Struct<{
    readonly formatVersion: Schema.Literal<1>;
    readonly accessToken: Schema.String;
    readonly idToken: Schema.String;
    readonly refreshToken: Schema.String;
    readonly accountId: Schema.String;
    readonly fingerprint: Schema.String;
    readonly generation: Schema.String;
    readonly expiresAt: Schema.Finite;
    readonly refreshedAt: Schema.Finite;
}>;
type CredentialDisk = typeof CredentialDisk.Type;
/** @experimental */
export interface Credential {
    readonly accessToken: Redacted.Redacted<string>;
    readonly idToken: Redacted.Redacted<string>;
    readonly refreshToken: Redacted.Redacted<string>;
    readonly accountId: Redacted.Redacted<string>;
    readonly fingerprint: string;
    readonly generation: string;
    readonly expiresAt: number;
    readonly refreshedAt: number;
}
/** @experimental */
export interface StoreInterface {
    readonly load: Effect.Effect<Option.Option<CredentialDisk>, StoreError>;
    readonly save: (credential: CredentialDisk) => Effect.Effect<void, StoreError>;
    readonly remove: Effect.Effect<boolean, StoreError>;
    readonly serialized: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | StoreError, R>;
}
declare const OpenAiAccountCredentialStore_base: Context.ServiceClass<OpenAiAccountCredentialStore, "@batonfx/providers/provider/openai-account-auth/OpenAiAccountCredentialStore", StoreInterface>;
/** @experimental */
export declare class OpenAiAccountCredentialStore extends OpenAiAccountCredentialStore_base {
}
/** @experimental */
export declare const makePkce: Effect.Effect<{
    verifier: Redacted.Redacted<string>;
    challenge: string;
    state: Redacted.Redacted<string>;
}, AuthError, Crypto.Crypto>;
/** @experimental */
export declare const authorizationUrl: {
    (challenge: string, state: Redacted.Redacted<string>, redirect?: string): URL;
    (state: Redacted.Redacted<string>, redirect?: string): (challenge: string) => URL;
};
/** @experimental */
export type Status = {
    readonly _tag: "Unauthenticated";
} | {
    readonly _tag: "Present";
    readonly fingerprint: string;
} | {
    readonly _tag: "RefreshRequired";
    readonly fingerprint: string;
} | {
    readonly _tag: "Corrupt";
};
/** @experimental */
export interface ServiceInterface {
    readonly loginBrowser: (redirect?: string) => Effect.Effect<Credential, Error>;
    readonly loginDevice: Effect.Effect<Credential, Error>;
    readonly status: Effect.Effect<Status, StoreError>;
    readonly logout: Effect.Effect<{
        readonly removed: boolean;
        readonly revocationSupported: false;
    }, StoreError>;
    readonly acquire: Effect.Effect<Credential, Error>;
    readonly refreshRejected: (generation: string) => Effect.Effect<Credential, Error>;
}
declare const OpenAiAccountAuth_base: Context.ServiceClass<OpenAiAccountAuth, "@batonfx/providers/provider/openai-account-auth/OpenAiAccountAuth", ServiceInterface>;
/** @experimental */
export declare class OpenAiAccountAuth extends OpenAiAccountAuth_base {
}
/** @experimental */
export interface TimingOptions {
    readonly deviceTimeout?: number;
}
/** @experimental */
export declare const layer: (options?: TimingOptions) => Layer.Layer<OpenAiAccountAuth, never, Crypto.Crypto | OpenAiAccountAuthHost | OpenAiAccountAuthHttp | OpenAiAccountCredentialStore | OpenAiAccountDevicePresenter>;
/** @experimental */
export declare const layerHostTest: (implementation: HostInterface) => Layer.Layer<OpenAiAccountAuthHost>;
/** @experimental */
export declare const layerPresenterTest: (implementation: PresenterInterface) => Layer.Layer<OpenAiAccountDevicePresenter>;
/** @experimental */
export declare const layerHttpTest: (implementation: HttpInterface) => Layer.Layer<OpenAiAccountAuthHttp>;
/** @experimental */
export declare const layerStoreTest: (implementation: StoreInterface) => Layer.Layer<OpenAiAccountCredentialStore>;
export {};