weave-typescript 0.4.5 → 0.5.0

package/dist/weaveapi/auth/v1/service.pb.d.ts

@@ -0,0 +1,705 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { type CallOptions, ChannelCredentials, Client, type ClientOptions, type ClientUnaryCall, type handleUnaryCall, Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
+import { Session } from "./session.pb";
+import { UsageLimits, UsageStats } from "./usage.pb";
+import { APIKey, OAuthProvider, User, UserPreferences } from "./user.pb";
+export declare const protobufPackage = "weaveapi.auth.v1";
+export interface InitiateOAuthRequest {
+    /** github, google, microsoft, gitlab */
+    provider: string;
+    /** Optional custom redirect */
+    redirectUri: string;
+    /** CSRF protection */
+    state: string;
+    /** OAuth scopes (provider-specific) */
+    scope: string;
+    /** Additional provider-specific params */
+    providerParams: {
+        [key: string]: string;
+    };
+}
+export interface InitiateOAuthRequest_ProviderParamsEntry {
+    key: string;
+    value: string;
+}
+export interface InitiateOAuthResponse {
+    /** OAuth provider URL to redirect to */
+    authUrl: string;
+    /** State parameter for CSRF */
+    state: string;
+    /** For PKCE flow (if supported) */
+    codeVerifier: string;
+    /** Provider name for confirmation */
+    provider: string;
+}
+export interface HandleOAuthCallbackRequest {
+    /** github, google, microsoft, gitlab */
+    provider: string;
+    /** OAuth authorization code */
+    code: string;
+    /** CSRF state parameter */
+    state: string;
+    /** For PKCE flow (if supported) */
+    codeVerifier: string;
+    /** OAuth error if any */
+    error: string;
+    /** Error details */
+    errorDescription: string;
+}
+export interface HandleOAuthCallbackResponse {
+    /** JWT access token */
+    accessToken: string;
+    /** JWT refresh token */
+    refreshToken: string;
+    /** Seconds until access token expires */
+    expiresIn: number;
+    /** User profile */
+    user: User | undefined;
+    /** True if user was just created */
+    isNewUser: boolean;
+    /** Where to redirect in the UI */
+    redirectUrl: string;
+    /** Which provider was used */
+    linkedProvider: string;
+    /** True if linked to existing account */
+    accountLinked: boolean;
+}
+export interface GetOAuthProvidersRequest {
+    /** Only return enabled providers */
+    enabledOnly: boolean;
+}
+export interface GetOAuthProvidersResponse {
+    providers: OAuthProvider[];
+    /** Recommended provider */
+    primaryProvider: string;
+}
+export interface LinkOAuthProviderRequest {
+    /** Provider to link */
+    provider: string;
+    /** Where to redirect after linking */
+    redirectUri: string;
+}
+export interface LinkOAuthProviderResponse {
+    /** OAuth URL to start linking flow */
+    authUrl: string;
+    /** CSRF state */
+    state: string;
+}
+export interface UnlinkOAuthProviderRequest {
+    /** Provider to unlink */
+    provider: string;
+}
+export interface UnlinkOAuthProviderResponse {
+    success: boolean;
+    message: string;
+    /** Number of providers still linked */
+    remainingProviders: number;
+}
+export interface RefreshTokenRequest {
+    refreshToken: string;
+}
+export interface RefreshTokenResponse {
+    accessToken: string;
+    /** New refresh token */
+    refreshToken: string;
+    expiresIn: number;
+}
+export interface RevokeTokenRequest {
+    refreshToken: string;
+}
+export interface RevokeTokenResponse {
+    success: boolean;
+    message: string;
+}
+export interface ValidateTokenRequest {
+    accessToken: string;
+}
+export interface ValidateTokenResponse {
+    valid: boolean;
+    userId: string;
+    scopes: string[];
+    expiresAt: Date | undefined;
+    /** free, pro */
+    tier: string;
+}
+/** Uses JWT from Authorization header */
+export interface GetCurrentUserRequest {
+}
+export interface GetCurrentUserResponse {
+    user: User | undefined;
+}
+export interface UpdateUserRequest {
+    fullName: string;
+    email: string;
+    preferences: UserPreferences | undefined;
+}
+export interface UpdateUserResponse {
+    user: User | undefined;
+}
+export interface DeleteUserRequest {
+    /** Must be "DELETE" */
+    confirmation: string;
+    /** For extra security */
+    password: string;
+}
+export interface DeleteUserResponse {
+    success: boolean;
+    message: string;
+    /** 30-day grace period */
+    scheduledDeletionAt: Date | undefined;
+}
+export interface ListAPIKeysRequest {
+    pageSize: number;
+    pageToken: string;
+    activeOnly: boolean;
+}
+export interface ListAPIKeysResponse {
+    apiKeys: APIKey[];
+    nextPageToken: string;
+    totalCount: number;
+}
+export interface CreateAPIKeyRequest {
+    name: string;
+    description: string;
+    /** read, write */
+    scopes: string[];
+    /** Optional endpoint restrictions */
+    allowedEndpoints: string[];
+    /** Optional IP whitelist */
+    allowedIps: string[];
+    /** Optional expiration */
+    expiresAt: Date | undefined;
+}
+export interface CreateAPIKeyResponse {
+    apiKey: APIKey | undefined;
+    /** Full key, only shown once */
+    secretKey: string;
+    /** "Store this key securely, it won't be shown again" */
+    warning: string;
+}
+export interface GetAPIKeyRequest {
+    keyId: string;
+}
+export interface GetAPIKeyResponse {
+    apiKey: APIKey | undefined;
+}
+export interface UpdateAPIKeyRequest {
+    keyId: string;
+    name: string;
+    description: string;
+    allowedEndpoints: string[];
+    allowedIps: string[];
+    isActive: boolean;
+}
+export interface UpdateAPIKeyResponse {
+    apiKey: APIKey | undefined;
+}
+export interface RevokeAPIKeyRequest {
+    keyId: string;
+}
+export interface RevokeAPIKeyResponse {
+    success: boolean;
+    message: string;
+}
+export interface ValidateAPIKeyRequest {
+    /** Full API key */
+    apiKey: string;
+    /** Endpoint being accessed */
+    endpoint: string;
+    /** Request IP */
+    ipAddress: string;
+}
+export interface ValidateAPIKeyResponse {
+    valid: boolean;
+    userId: string;
+    /** free, pro */
+    tier: string;
+    scopes: string[];
+    rateLimit: RateLimitInfo | undefined;
+    /** If invalid */
+    rejectionReason: string;
+}
+export interface GetUsageStatsRequest {
+    /** today, week, month, all */
+    period: string;
+    /** Optional: filter by specific key */
+    apiKeyId: string;
+}
+export interface GetUsageStatsResponse {
+    currentPeriod: UsageStats | undefined;
+    /** Past periods */
+    historical: UsageStats[];
+    limits: UsageLimits | undefined;
+}
+export interface GetRateLimitStatusRequest {
+    /** Optional: check specific key */
+    apiKeyId: string;
+}
+export interface GetRateLimitStatusResponse {
+    current: RateLimitInfo | undefined;
+    byEndpoint: RateLimitInfo[];
+}
+export interface RateLimitInfo {
+    tier: string;
+    /** hour, minute */
+    window: string;
+    limit: number;
+    remaining: number;
+    resetAt: Date | undefined;
+    isLimited: boolean;
+}
+export interface ListSessionsRequest {
+    pageSize: number;
+    pageToken: string;
+}
+export interface ListSessionsResponse {
+    sessions: Session[];
+    nextPageToken: string;
+    totalCount: number;
+    currentSessionId: string;
+}
+export interface RevokeSessionRequest {
+    sessionId: string;
+}
+export interface RevokeSessionResponse {
+    success: boolean;
+    message: string;
+}
+export interface RevokeAllSessionsRequest {
+    /** Keep the session making this request */
+    keepCurrent: boolean;
+}
+export interface RevokeAllSessionsResponse {
+    revokedCount: number;
+    message: string;
+}
+export declare const InitiateOAuthRequest: MessageFns<InitiateOAuthRequest>;
+export declare const InitiateOAuthRequest_ProviderParamsEntry: MessageFns<InitiateOAuthRequest_ProviderParamsEntry>;
+export declare const InitiateOAuthResponse: MessageFns<InitiateOAuthResponse>;
+export declare const HandleOAuthCallbackRequest: MessageFns<HandleOAuthCallbackRequest>;
+export declare const HandleOAuthCallbackResponse: MessageFns<HandleOAuthCallbackResponse>;
+export declare const GetOAuthProvidersRequest: MessageFns<GetOAuthProvidersRequest>;
+export declare const GetOAuthProvidersResponse: MessageFns<GetOAuthProvidersResponse>;
+export declare const LinkOAuthProviderRequest: MessageFns<LinkOAuthProviderRequest>;
+export declare const LinkOAuthProviderResponse: MessageFns<LinkOAuthProviderResponse>;
+export declare const UnlinkOAuthProviderRequest: MessageFns<UnlinkOAuthProviderRequest>;
+export declare const UnlinkOAuthProviderResponse: MessageFns<UnlinkOAuthProviderResponse>;
+export declare const RefreshTokenRequest: MessageFns<RefreshTokenRequest>;
+export declare const RefreshTokenResponse: MessageFns<RefreshTokenResponse>;
+export declare const RevokeTokenRequest: MessageFns<RevokeTokenRequest>;
+export declare const RevokeTokenResponse: MessageFns<RevokeTokenResponse>;
+export declare const ValidateTokenRequest: MessageFns<ValidateTokenRequest>;
+export declare const ValidateTokenResponse: MessageFns<ValidateTokenResponse>;
+export declare const GetCurrentUserRequest: MessageFns<GetCurrentUserRequest>;
+export declare const GetCurrentUserResponse: MessageFns<GetCurrentUserResponse>;
+export declare const UpdateUserRequest: MessageFns<UpdateUserRequest>;
+export declare const UpdateUserResponse: MessageFns<UpdateUserResponse>;
+export declare const DeleteUserRequest: MessageFns<DeleteUserRequest>;
+export declare const DeleteUserResponse: MessageFns<DeleteUserResponse>;
+export declare const ListAPIKeysRequest: MessageFns<ListAPIKeysRequest>;
+export declare const ListAPIKeysResponse: MessageFns<ListAPIKeysResponse>;
+export declare const CreateAPIKeyRequest: MessageFns<CreateAPIKeyRequest>;
+export declare const CreateAPIKeyResponse: MessageFns<CreateAPIKeyResponse>;
+export declare const GetAPIKeyRequest: MessageFns<GetAPIKeyRequest>;
+export declare const GetAPIKeyResponse: MessageFns<GetAPIKeyResponse>;
+export declare const UpdateAPIKeyRequest: MessageFns<UpdateAPIKeyRequest>;
+export declare const UpdateAPIKeyResponse: MessageFns<UpdateAPIKeyResponse>;
+export declare const RevokeAPIKeyRequest: MessageFns<RevokeAPIKeyRequest>;
+export declare const RevokeAPIKeyResponse: MessageFns<RevokeAPIKeyResponse>;
+export declare const ValidateAPIKeyRequest: MessageFns<ValidateAPIKeyRequest>;
+export declare const ValidateAPIKeyResponse: MessageFns<ValidateAPIKeyResponse>;
+export declare const GetUsageStatsRequest: MessageFns<GetUsageStatsRequest>;
+export declare const GetUsageStatsResponse: MessageFns<GetUsageStatsResponse>;
+export declare const GetRateLimitStatusRequest: MessageFns<GetRateLimitStatusRequest>;
+export declare const GetRateLimitStatusResponse: MessageFns<GetRateLimitStatusResponse>;
+export declare const RateLimitInfo: MessageFns<RateLimitInfo>;
+export declare const ListSessionsRequest: MessageFns<ListSessionsRequest>;
+export declare const ListSessionsResponse: MessageFns<ListSessionsResponse>;
+export declare const RevokeSessionRequest: MessageFns<RevokeSessionRequest>;
+export declare const RevokeSessionResponse: MessageFns<RevokeSessionResponse>;
+export declare const RevokeAllSessionsRequest: MessageFns<RevokeAllSessionsRequest>;
+export declare const RevokeAllSessionsResponse: MessageFns<RevokeAllSessionsResponse>;
+/** Auth handles authentication and user management */
+export type AuthService = typeof AuthService;
+export declare const AuthService: {
+    /** Initiate OAuth flow for any supported provider */
+    readonly initiateOAuth: {
+        readonly path: "/weaveapi.auth.v1.Auth/InitiateOAuth";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: InitiateOAuthRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => InitiateOAuthRequest;
+        readonly responseSerialize: (value: InitiateOAuthResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => InitiateOAuthResponse;
+    };
+    /** Handle OAuth callback from any provider */
+    readonly handleOAuthCallback: {
+        readonly path: "/weaveapi.auth.v1.Auth/HandleOAuthCallback";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: HandleOAuthCallbackRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => HandleOAuthCallbackRequest;
+        readonly responseSerialize: (value: HandleOAuthCallbackResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => HandleOAuthCallbackResponse;
+    };
+    /** Get list of supported OAuth providers */
+    readonly getOAuthProviders: {
+        readonly path: "/weaveapi.auth.v1.Auth/GetOAuthProviders";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetOAuthProvidersRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GetOAuthProvidersRequest;
+        readonly responseSerialize: (value: GetOAuthProvidersResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GetOAuthProvidersResponse;
+    };
+    /** Link additional OAuth provider to existing account */
+    readonly linkOAuthProvider: {
+        readonly path: "/weaveapi.auth.v1.Auth/LinkOAuthProvider";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: LinkOAuthProviderRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => LinkOAuthProviderRequest;
+        readonly responseSerialize: (value: LinkOAuthProviderResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => LinkOAuthProviderResponse;
+    };
+    /** Unlink OAuth provider from account */
+    readonly unlinkOAuthProvider: {
+        readonly path: "/weaveapi.auth.v1.Auth/UnlinkOAuthProvider";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UnlinkOAuthProviderRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => UnlinkOAuthProviderRequest;
+        readonly responseSerialize: (value: UnlinkOAuthProviderResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => UnlinkOAuthProviderResponse;
+    };
+    /** Refresh access token */
+    readonly refreshToken: {
+        readonly path: "/weaveapi.auth.v1.Auth/RefreshToken";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: RefreshTokenRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => RefreshTokenRequest;
+        readonly responseSerialize: (value: RefreshTokenResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => RefreshTokenResponse;
+    };
+    /** Revoke refresh token (logout) */
+    readonly revokeToken: {
+        readonly path: "/weaveapi.auth.v1.Auth/RevokeToken";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: RevokeTokenRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => RevokeTokenRequest;
+        readonly responseSerialize: (value: RevokeTokenResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => RevokeTokenResponse;
+    };
+    /** Validate access token */
+    readonly validateToken: {
+        readonly path: "/weaveapi.auth.v1.Auth/ValidateToken";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ValidateTokenRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => ValidateTokenRequest;
+        readonly responseSerialize: (value: ValidateTokenResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => ValidateTokenResponse;
+    };
+    /** Get current user profile */
+    readonly getCurrentUser: {
+        readonly path: "/weaveapi.auth.v1.Auth/GetCurrentUser";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetCurrentUserRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GetCurrentUserRequest;
+        readonly responseSerialize: (value: GetCurrentUserResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GetCurrentUserResponse;
+    };
+    /** Update user profile */
+    readonly updateUser: {
+        readonly path: "/weaveapi.auth.v1.Auth/UpdateUser";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UpdateUserRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => UpdateUserRequest;
+        readonly responseSerialize: (value: UpdateUserResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => UpdateUserResponse;
+    };
+    /** Delete user account */
+    readonly deleteUser: {
+        readonly path: "/weaveapi.auth.v1.Auth/DeleteUser";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DeleteUserRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => DeleteUserRequest;
+        readonly responseSerialize: (value: DeleteUserResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => DeleteUserResponse;
+    };
+    /** List user's API keys */
+    readonly listApiKeys: {
+        readonly path: "/weaveapi.auth.v1.Auth/ListAPIKeys";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ListAPIKeysRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => ListAPIKeysRequest;
+        readonly responseSerialize: (value: ListAPIKeysResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => ListAPIKeysResponse;
+    };
+    /** Create new API key */
+    readonly createApiKey: {
+        readonly path: "/weaveapi.auth.v1.Auth/CreateAPIKey";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CreateAPIKeyRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => CreateAPIKeyRequest;
+        readonly responseSerialize: (value: CreateAPIKeyResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => CreateAPIKeyResponse;
+    };
+    /** Get API key details */
+    readonly getApiKey: {
+        readonly path: "/weaveapi.auth.v1.Auth/GetAPIKey";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetAPIKeyRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GetAPIKeyRequest;
+        readonly responseSerialize: (value: GetAPIKeyResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GetAPIKeyResponse;
+    };
+    /** Update API key (rename, etc) */
+    readonly updateApiKey: {
+        readonly path: "/weaveapi.auth.v1.Auth/UpdateAPIKey";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UpdateAPIKeyRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => UpdateAPIKeyRequest;
+        readonly responseSerialize: (value: UpdateAPIKeyResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => UpdateAPIKeyResponse;
+    };
+    /** Revoke API key */
+    readonly revokeApiKey: {
+        readonly path: "/weaveapi.auth.v1.Auth/RevokeAPIKey";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: RevokeAPIKeyRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => RevokeAPIKeyRequest;
+        readonly responseSerialize: (value: RevokeAPIKeyResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => RevokeAPIKeyResponse;
+    };
+    /** Validate API key (for internal use) */
+    readonly validateApiKey: {
+        readonly path: "/weaveapi.auth.v1.Auth/ValidateAPIKey";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ValidateAPIKeyRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => ValidateAPIKeyRequest;
+        readonly responseSerialize: (value: ValidateAPIKeyResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => ValidateAPIKeyResponse;
+    };
+    /** Get user's API usage statistics */
+    readonly getUsageStats: {
+        readonly path: "/weaveapi.auth.v1.Auth/GetUsageStats";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetUsageStatsRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GetUsageStatsRequest;
+        readonly responseSerialize: (value: GetUsageStatsResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GetUsageStatsResponse;
+    };
+    /** Get rate limit status */
+    readonly getRateLimitStatus: {
+        readonly path: "/weaveapi.auth.v1.Auth/GetRateLimitStatus";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetRateLimitStatusRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GetRateLimitStatusRequest;
+        readonly responseSerialize: (value: GetRateLimitStatusResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GetRateLimitStatusResponse;
+    };
+    /** List active sessions */
+    readonly listSessions: {
+        readonly path: "/weaveapi.auth.v1.Auth/ListSessions";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ListSessionsRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => ListSessionsRequest;
+        readonly responseSerialize: (value: ListSessionsResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => ListSessionsResponse;
+    };
+    /** Revoke a specific session */
+    readonly revokeSession: {
+        readonly path: "/weaveapi.auth.v1.Auth/RevokeSession";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: RevokeSessionRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => RevokeSessionRequest;
+        readonly responseSerialize: (value: RevokeSessionResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => RevokeSessionResponse;
+    };
+    /** Revoke all sessions except current */
+    readonly revokeAllSessions: {
+        readonly path: "/weaveapi.auth.v1.Auth/RevokeAllSessions";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: RevokeAllSessionsRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => RevokeAllSessionsRequest;
+        readonly responseSerialize: (value: RevokeAllSessionsResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => RevokeAllSessionsResponse;
+    };
+};
+export interface AuthServer extends UntypedServiceImplementation {
+    /** Initiate OAuth flow for any supported provider */
+    initiateOAuth: handleUnaryCall<InitiateOAuthRequest, InitiateOAuthResponse>;
+    /** Handle OAuth callback from any provider */
+    handleOAuthCallback: handleUnaryCall<HandleOAuthCallbackRequest, HandleOAuthCallbackResponse>;
+    /** Get list of supported OAuth providers */
+    getOAuthProviders: handleUnaryCall<GetOAuthProvidersRequest, GetOAuthProvidersResponse>;
+    /** Link additional OAuth provider to existing account */
+    linkOAuthProvider: handleUnaryCall<LinkOAuthProviderRequest, LinkOAuthProviderResponse>;
+    /** Unlink OAuth provider from account */
+    unlinkOAuthProvider: handleUnaryCall<UnlinkOAuthProviderRequest, UnlinkOAuthProviderResponse>;
+    /** Refresh access token */
+    refreshToken: handleUnaryCall<RefreshTokenRequest, RefreshTokenResponse>;
+    /** Revoke refresh token (logout) */
+    revokeToken: handleUnaryCall<RevokeTokenRequest, RevokeTokenResponse>;
+    /** Validate access token */
+    validateToken: handleUnaryCall<ValidateTokenRequest, ValidateTokenResponse>;
+    /** Get current user profile */
+    getCurrentUser: handleUnaryCall<GetCurrentUserRequest, GetCurrentUserResponse>;
+    /** Update user profile */
+    updateUser: handleUnaryCall<UpdateUserRequest, UpdateUserResponse>;
+    /** Delete user account */
+    deleteUser: handleUnaryCall<DeleteUserRequest, DeleteUserResponse>;
+    /** List user's API keys */
+    listApiKeys: handleUnaryCall<ListAPIKeysRequest, ListAPIKeysResponse>;
+    /** Create new API key */
+    createApiKey: handleUnaryCall<CreateAPIKeyRequest, CreateAPIKeyResponse>;
+    /** Get API key details */
+    getApiKey: handleUnaryCall<GetAPIKeyRequest, GetAPIKeyResponse>;
+    /** Update API key (rename, etc) */
+    updateApiKey: handleUnaryCall<UpdateAPIKeyRequest, UpdateAPIKeyResponse>;
+    /** Revoke API key */
+    revokeApiKey: handleUnaryCall<RevokeAPIKeyRequest, RevokeAPIKeyResponse>;
+    /** Validate API key (for internal use) */
+    validateApiKey: handleUnaryCall<ValidateAPIKeyRequest, ValidateAPIKeyResponse>;
+    /** Get user's API usage statistics */
+    getUsageStats: handleUnaryCall<GetUsageStatsRequest, GetUsageStatsResponse>;
+    /** Get rate limit status */
+    getRateLimitStatus: handleUnaryCall<GetRateLimitStatusRequest, GetRateLimitStatusResponse>;
+    /** List active sessions */
+    listSessions: handleUnaryCall<ListSessionsRequest, ListSessionsResponse>;
+    /** Revoke a specific session */
+    revokeSession: handleUnaryCall<RevokeSessionRequest, RevokeSessionResponse>;
+    /** Revoke all sessions except current */
+    revokeAllSessions: handleUnaryCall<RevokeAllSessionsRequest, RevokeAllSessionsResponse>;
+}
+export interface AuthClient extends Client {
+    /** Initiate OAuth flow for any supported provider */
+    initiateOAuth(request: InitiateOAuthRequest, callback: (error: ServiceError | null, response: InitiateOAuthResponse) => void): ClientUnaryCall;
+    initiateOAuth(request: InitiateOAuthRequest, metadata: Metadata, callback: (error: ServiceError | null, response: InitiateOAuthResponse) => void): ClientUnaryCall;
+    initiateOAuth(request: InitiateOAuthRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: InitiateOAuthResponse) => void): ClientUnaryCall;
+    /** Handle OAuth callback from any provider */
+    handleOAuthCallback(request: HandleOAuthCallbackRequest, callback: (error: ServiceError | null, response: HandleOAuthCallbackResponse) => void): ClientUnaryCall;
+    handleOAuthCallback(request: HandleOAuthCallbackRequest, metadata: Metadata, callback: (error: ServiceError | null, response: HandleOAuthCallbackResponse) => void): ClientUnaryCall;
+    handleOAuthCallback(request: HandleOAuthCallbackRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: HandleOAuthCallbackResponse) => void): ClientUnaryCall;
+    /** Get list of supported OAuth providers */
+    getOAuthProviders(request: GetOAuthProvidersRequest, callback: (error: ServiceError | null, response: GetOAuthProvidersResponse) => void): ClientUnaryCall;
+    getOAuthProviders(request: GetOAuthProvidersRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetOAuthProvidersResponse) => void): ClientUnaryCall;
+    getOAuthProviders(request: GetOAuthProvidersRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetOAuthProvidersResponse) => void): ClientUnaryCall;
+    /** Link additional OAuth provider to existing account */
+    linkOAuthProvider(request: LinkOAuthProviderRequest, callback: (error: ServiceError | null, response: LinkOAuthProviderResponse) => void): ClientUnaryCall;
+    linkOAuthProvider(request: LinkOAuthProviderRequest, metadata: Metadata, callback: (error: ServiceError | null, response: LinkOAuthProviderResponse) => void): ClientUnaryCall;
+    linkOAuthProvider(request: LinkOAuthProviderRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: LinkOAuthProviderResponse) => void): ClientUnaryCall;
+    /** Unlink OAuth provider from account */
+    unlinkOAuthProvider(request: UnlinkOAuthProviderRequest, callback: (error: ServiceError | null, response: UnlinkOAuthProviderResponse) => void): ClientUnaryCall;
+    unlinkOAuthProvider(request: UnlinkOAuthProviderRequest, metadata: Metadata, callback: (error: ServiceError | null, response: UnlinkOAuthProviderResponse) => void): ClientUnaryCall;
+    unlinkOAuthProvider(request: UnlinkOAuthProviderRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: UnlinkOAuthProviderResponse) => void): ClientUnaryCall;
+    /** Refresh access token */
+    refreshToken(request: RefreshTokenRequest, callback: (error: ServiceError | null, response: RefreshTokenResponse) => void): ClientUnaryCall;
+    refreshToken(request: RefreshTokenRequest, metadata: Metadata, callback: (error: ServiceError | null, response: RefreshTokenResponse) => void): ClientUnaryCall;
+    refreshToken(request: RefreshTokenRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: RefreshTokenResponse) => void): ClientUnaryCall;
+    /** Revoke refresh token (logout) */
+    revokeToken(request: RevokeTokenRequest, callback: (error: ServiceError | null, response: RevokeTokenResponse) => void): ClientUnaryCall;
+    revokeToken(request: RevokeTokenRequest, metadata: Metadata, callback: (error: ServiceError | null, response: RevokeTokenResponse) => void): ClientUnaryCall;
+    revokeToken(request: RevokeTokenRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: RevokeTokenResponse) => void): ClientUnaryCall;
+    /** Validate access token */
+    validateToken(request: ValidateTokenRequest, callback: (error: ServiceError | null, response: ValidateTokenResponse) => void): ClientUnaryCall;
+    validateToken(request: ValidateTokenRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ValidateTokenResponse) => void): ClientUnaryCall;
+    validateToken(request: ValidateTokenRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ValidateTokenResponse) => void): ClientUnaryCall;
+    /** Get current user profile */
+    getCurrentUser(request: GetCurrentUserRequest, callback: (error: ServiceError | null, response: GetCurrentUserResponse) => void): ClientUnaryCall;
+    getCurrentUser(request: GetCurrentUserRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetCurrentUserResponse) => void): ClientUnaryCall;
+    getCurrentUser(request: GetCurrentUserRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetCurrentUserResponse) => void): ClientUnaryCall;
+    /** Update user profile */
+    updateUser(request: UpdateUserRequest, callback: (error: ServiceError | null, response: UpdateUserResponse) => void): ClientUnaryCall;
+    updateUser(request: UpdateUserRequest, metadata: Metadata, callback: (error: ServiceError | null, response: UpdateUserResponse) => void): ClientUnaryCall;
+    updateUser(request: UpdateUserRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: UpdateUserResponse) => void): ClientUnaryCall;
+    /** Delete user account */
+    deleteUser(request: DeleteUserRequest, callback: (error: ServiceError | null, response: DeleteUserResponse) => void): ClientUnaryCall;
+    deleteUser(request: DeleteUserRequest, metadata: Metadata, callback: (error: ServiceError | null, response: DeleteUserResponse) => void): ClientUnaryCall;
+    deleteUser(request: DeleteUserRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: DeleteUserResponse) => void): ClientUnaryCall;
+    /** List user's API keys */
+    listApiKeys(request: ListAPIKeysRequest, callback: (error: ServiceError | null, response: ListAPIKeysResponse) => void): ClientUnaryCall;
+    listApiKeys(request: ListAPIKeysRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ListAPIKeysResponse) => void): ClientUnaryCall;
+    listApiKeys(request: ListAPIKeysRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ListAPIKeysResponse) => void): ClientUnaryCall;
+    /** Create new API key */
+    createApiKey(request: CreateAPIKeyRequest, callback: (error: ServiceError | null, response: CreateAPIKeyResponse) => void): ClientUnaryCall;
+    createApiKey(request: CreateAPIKeyRequest, metadata: Metadata, callback: (error: ServiceError | null, response: CreateAPIKeyResponse) => void): ClientUnaryCall;
+    createApiKey(request: CreateAPIKeyRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: CreateAPIKeyResponse) => void): ClientUnaryCall;
+    /** Get API key details */
+    getApiKey(request: GetAPIKeyRequest, callback: (error: ServiceError | null, response: GetAPIKeyResponse) => void): ClientUnaryCall;
+    getApiKey(request: GetAPIKeyRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetAPIKeyResponse) => void): ClientUnaryCall;
+    getApiKey(request: GetAPIKeyRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetAPIKeyResponse) => void): ClientUnaryCall;
+    /** Update API key (rename, etc) */
+    updateApiKey(request: UpdateAPIKeyRequest, callback: (error: ServiceError | null, response: UpdateAPIKeyResponse) => void): ClientUnaryCall;
+    updateApiKey(request: UpdateAPIKeyRequest, metadata: Metadata, callback: (error: ServiceError | null, response: UpdateAPIKeyResponse) => void): ClientUnaryCall;
+    updateApiKey(request: UpdateAPIKeyRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: UpdateAPIKeyResponse) => void): ClientUnaryCall;
+    /** Revoke API key */
+    revokeApiKey(request: RevokeAPIKeyRequest, callback: (error: ServiceError | null, response: RevokeAPIKeyResponse) => void): ClientUnaryCall;
+    revokeApiKey(request: RevokeAPIKeyRequest, metadata: Metadata, callback: (error: ServiceError | null, response: RevokeAPIKeyResponse) => void): ClientUnaryCall;
+    revokeApiKey(request: RevokeAPIKeyRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: RevokeAPIKeyResponse) => void): ClientUnaryCall;
+    /** Validate API key (for internal use) */
+    validateApiKey(request: ValidateAPIKeyRequest, callback: (error: ServiceError | null, response: ValidateAPIKeyResponse) => void): ClientUnaryCall;
+    validateApiKey(request: ValidateAPIKeyRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ValidateAPIKeyResponse) => void): ClientUnaryCall;
+    validateApiKey(request: ValidateAPIKeyRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ValidateAPIKeyResponse) => void): ClientUnaryCall;
+    /** Get user's API usage statistics */
+    getUsageStats(request: GetUsageStatsRequest, callback: (error: ServiceError | null, response: GetUsageStatsResponse) => void): ClientUnaryCall;
+    getUsageStats(request: GetUsageStatsRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetUsageStatsResponse) => void): ClientUnaryCall;
+    getUsageStats(request: GetUsageStatsRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetUsageStatsResponse) => void): ClientUnaryCall;
+    /** Get rate limit status */
+    getRateLimitStatus(request: GetRateLimitStatusRequest, callback: (error: ServiceError | null, response: GetRateLimitStatusResponse) => void): ClientUnaryCall;
+    getRateLimitStatus(request: GetRateLimitStatusRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetRateLimitStatusResponse) => void): ClientUnaryCall;
+    getRateLimitStatus(request: GetRateLimitStatusRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetRateLimitStatusResponse) => void): ClientUnaryCall;
+    /** List active sessions */
+    listSessions(request: ListSessionsRequest, callback: (error: ServiceError | null, response: ListSessionsResponse) => void): ClientUnaryCall;
+    listSessions(request: ListSessionsRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ListSessionsResponse) => void): ClientUnaryCall;
+    listSessions(request: ListSessionsRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ListSessionsResponse) => void): ClientUnaryCall;
+    /** Revoke a specific session */
+    revokeSession(request: RevokeSessionRequest, callback: (error: ServiceError | null, response: RevokeSessionResponse) => void): ClientUnaryCall;
+    revokeSession(request: RevokeSessionRequest, metadata: Metadata, callback: (error: ServiceError | null, response: RevokeSessionResponse) => void): ClientUnaryCall;
+    revokeSession(request: RevokeSessionRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: RevokeSessionResponse) => void): ClientUnaryCall;
+    /** Revoke all sessions except current */
+    revokeAllSessions(request: RevokeAllSessionsRequest, callback: (error: ServiceError | null, response: RevokeAllSessionsResponse) => void): ClientUnaryCall;
+    revokeAllSessions(request: RevokeAllSessionsRequest, metadata: Metadata, callback: (error: ServiceError | null, response: RevokeAllSessionsResponse) => void): ClientUnaryCall;
+    revokeAllSessions(request: RevokeAllSessionsRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: RevokeAllSessionsResponse) => void): ClientUnaryCall;
+}
+export declare const AuthClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): AuthClient;
+    service: typeof AuthService;
+    serviceName: string;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};