import type { AuthEnvId } from '@knapsack/core';
import type { RendererIdsForNativeMobile } from '@knapsack/types';
export type KsLogMeta = {
    siteId?: string;
    orgId?: string;
    /**
     * Consider using `instanceType` instead.
     */
    instanceId?: string;
    instanceType?: 'branch' | 'latest' | 'dev' | 'preview';
    appClientUrl?: string;
    /**
     * Version of `@knapsack/app` that is running (even if this log happens in UI or other)
     */
    appClientVersion?: string;
};
/**
 * @link https://docs.datadoghq.com/logs/processing/attributes_naming_convention/
 */
export type LogMetadata = {
    message?: string;
    service?: string;
    env?: string;
    version?: string;
    logger?: {
        name: string;
    };
    error?: Error;
    http?: {
        url?: string;
        status_code?: string;
        method?: string;
        referer?: string;
        requestBody?: Record<string, any>;
        responseBody?: Record<string, any>;
        query?: Record<string, any>;
        headers?: Record<string, any>;
        requestId?: string;
    };
    /** GraphQL info - same shape as Hasura sends in */
    query?: {
        operationName: string;
        /** actual GraphQL query/mutation/subscription */
        query: string;
        variables: Record<string, any>;
    };
    /**
     * User
     */
    usr?: {
        /** KS User ID, not Auth0 ID - that's in `auth0Id` */
        id: string;
        isSuperAdmin?: boolean;
        siteRole?: string;
        name?: string;
        email?: string;
        auth0Id?: string;
    };
    syslog?: {
        env?: string;
        hostname?: string;
    };
    /**
     * Events
     */
    evt?: {
        name: 'api.createHasuraClient';
        outcome: 'success' | 'failure';
    } | {
        name: 'api.sendUserAccountEmail';
        action: 'sendUserAccountCreatedEmail' | 'sendSiteInviteEmail' | 'sendPasswordResetEmail';
        outcome: 'success' | 'failure';
    } | {
        name: 'api.native.getNativeComponentUploadUrl';
        outcome: 'success' | 'failure';
    } | {
        name: 'api.figmaApi.request';
        endpoint: 'me' | 'files' | 'images';
        method: 'GET' | 'POST';
        outcome: 'unknown' | 'success' | 'failure';
        tier: '1' | '2' | '3';
        figmaFileId?: string;
    } | {
        name: 'lambda.figmaApi.request';
        endpoint: 'files' | 'images' | 'cdn';
        method: 'GET' | 'POST';
        outcome: 'unknown' | 'success' | 'failure';
        tier: '1' | '2' | '3';
        figmaFileId?: string;
        figmaFileVersion?: string;
    } | {
        name: 'lambda.api.request';
        endpoint: string;
        method: 'GET' | 'POST';
        outcome: 'unknown';
    } | {
        name: 'lambda.s3.getObject';
        outcome: 'unknown';
    } | {
        name: 'api.deleteKsSite';
        outcome: 'success' | 'failure';
    } | {
        /**
         * A provider git webhook arrived for a site whose content lives in
         * the database (`isKsContentStoredInDb`) and was swallowed on
         * purpose. Provider-neutral: fired from `deleteBranchInDb`, which
         * serves every provider's merge/close handler. One facet answers
         * "show me webhook replays against this site since the flip."
         */
        name: 'api.gitWebhook.dbModeNoop';
        eventName: string;
        outcome: 'success';
    } | {
        name: `api.githubWebhook.${string}`;
        outcome: 'success' | 'failure';
    } | {
        name: `api.azureWebhook.${string}`;
        outcome: 'success' | 'failure';
    } | {
        name: `api.bitbucketCloudWebhook.${string}`;
        outcome: 'success' | 'failure';
    } | {
        name: `api.bitbucketDatacenterWebhook.${string}`;
        outcome: 'success' | 'failure';
    } | {
        name: `api.gitlabWebhook.${string}`;
        outcome: 'success' | 'failure';
    } | {
        name: `api.gql.${string}`;
        outcome: 'success' | 'failure';
    } | {
        name: `api.gql.error.${string}`;
        outcome: 'failure';
    } | {
        name: 'api.search.request';
        outcome: 'success' | 'failure';
        resultsCount: number;
    } | {
        name: 'api.search.index.update';
        outcome: 'success' | 'failure';
        resultsCount: number;
    } | {
        name: 'api.search.sourceData';
        outcome: 'success' | 'failure';
    } | {
        name: 'api.deleteInstance';
        outcome: 'success' | 'failure';
    } | {
        name: 'api.updateSiteSetup';
        outcome: 'success' | 'failure';
    } | {
        name: 'api.gitCommit';
        outcome: 'success' | 'failure';
    } | {
        name: 'api.site.contentFreeze';
        action: 'set' | 'cleared';
        cause: string;
        outcome: 'success' | 'failure';
        operator: string;
    } | {
        name: 'api.site.migrated';
        outcome: 'success' | 'failure';
        operator: string;
    } | {
        name: 'api.site.rolledBack';
        outcome: 'success' | 'failure';
        operator: string;
    } | {
        name: `api.zendesk${'UserFetch' | 'UserUpdate' | 'TicketCreated'}`;
        outcome: 'success' | 'failure';
    } | {
        name: `api.tokensConverted`;
        outcome: 'success' | 'failure';
        fromCache: boolean;
        time: number;
    } | {
        name: 'ui.auth.login';
        redirectUrl: string;
        queryParams: Record<string, string>;
        outcome: 'success' | 'failure';
    } | {
        name: 'ui.auth.callback';
        outcome: 'success' | 'failure';
    } | {
        name: 'ui.auth.startlogin';
        redirectUrl: string;
        queryParams: Record<string, string>;
        outcome: 'unknown';
    } | {
        name: 'ui.auth.error';
        outcome: 'failure';
    } | {
        /** Emitted when a video block's `<video>` element fails to load or play. */
        name: 'ui.videoBlock.playbackError';
        outcome: 'failure';
        /**
         * `HTMLMediaElement.error.code` — 1 ABORTED, 2 NETWORK, 3 DECODE,
         * 4 SRC_NOT_SUPPORTED.
         * @link https://developer.mozilla.org/en-US/docs/Web/API/MediaError/code
         */
        mediaErrorCode?: number;
    } | {
        name: 'api.auth.post-login-webhook.misc';
        authEnvId: AuthEnvId;
        outcome: 'success' | 'failure';
    } | {
        name: 'api.auth.get-custom-claims';
        authEnvId: AuthEnvId;
        authConnectionName: string;
        outcome: 'success' | 'failure';
    } | {
        name: 'api.auth.hasura-auth-handler';
        authEnvId?: AuthEnvId;
        outcome: 'success' | 'failure';
    } | {
        name: 'auth0.actions';
        trigger: 'post-login' | 'pre-user-registration' | 'post-user-registration' | 'credentials-exchange';
        action: 'add-custom-claims' | 'verify-service-credential';
        outcome: 'success' | 'failure';
    } | {
        name: `api.figmaDesignSrc${'UserFetch' | 'UserUpdate' | 'S3FileGet' | 'OAuthTokenFetch' | 'UserDelete' | 'LatestVersionFetch' | 'FigmaClientInitialized' | 'OAuthTokenValidation' | 'OAuthTokenRefresh' | 'RetryFailedNodes'}`;
        outcome: 'success' | 'failure';
    } | {
        name: `lambda.figmaDesignSrc${'ImageRefresh' | 'FetchFile' | 'ParseFile' | 'ExtractFile' | 'UploadFile' | 'ImageCache' | 'FetchParseFile' | 'FetchImage' | 'FetchImages' | 'ImageCheck' | 'OAuthTokenRefresh'}`;
        outcome: 'success' | 'failure' | 'partial_success';
        fileId?: string;
        figmaFileId?: string;
        figmaVersion?: string;
        figmaFileVersion?: string;
    } | {
        name: `lambda.hasura.${'getDesignSourceFileFigma' | 'insertDesignSourceFileFigma' | 'updateDesignSourceFileFigma' | 'updateDesignSourceFileFigmaStatus' | 'getDesignSourceUsersOAuth'}`;
        outcome: 'success' | 'failure';
        fileId?: string;
        figmaFileId?: string;
        figmaVersion?: string;
        figmaFileVersion?: string;
    } | {
        name: `lambda.s3.${'uploadDesignSrcFile' | 'uploadTempImageFile' | 'uploadImage' | 'uploadParsedFile'}`;
        outcome: 'success' | 'failure';
        fileId?: string;
        figmaFileId?: string;
        figmaVersion?: string;
        figmaFileVersion?: string;
    } | {
        name: 'lambda.s3.getObject';
        outcome: 'success' | 'failure' | 'unknown';
    } | {
        name: 'mandrill.webhook';
        event: 'add' | 'remove' | 'change' | 'send' | 'open' | 'click' | 'delivered' | 'deferral' | 'hard_bounce' | 'soft_bounce' | 'reject' | 'spam' | 'unsub' | 'parseError' | 'missingEvents' | 'noBody';
        fullEvent?: Record<string, any>;
        status: 'error' | 'warning' | 'info';
    } | {
        name: 'lambda.mandrill.webhook';
        event: 'add' | 'remove' | 'change' | 'send' | 'open' | 'click' | 'delivered' | 'deferral' | 'hard_bounce' | 'soft_bounce' | 'reject' | 'spam' | 'unsub' | 'parseError' | 'missingEvents' | 'noBody';
        fullEvent?: Record<string, any>;
        outcome: 'success' | 'failure' | 'warning';
    } | {
        name: 'lambda.auth.hasuraAuthHandler';
        authEnv?: AuthEnvId;
        outcome: 'success' | 'failure';
    } | {
        name: 'lambda.auth.hasuraAuthHandler.getSecret';
        outcome: 'success' | 'failure';
    } | {
        name: 'mcp.request.sse' | 'mcp.request.mcp';
        outcome: 'unknown';
        toolName?: string;
        toolArguments?: Record<string, any>;
        toolMetadata?: Record<string, any>;
    } | {
        name: 'mcp.response.sse' | 'mcp.response.mcp';
        outcome: 'success' | 'failure';
        toolName?: string;
        toolArguments?: Record<string, any>;
        toolMetadata?: Record<string, any>;
    } | {
        name: 'mcp.tool.use';
        outcome: 'success' | 'failure';
        toolName: string;
        toolArguments?: Record<string, any>;
        toolMetadata?: Record<string, any>;
    } | {
        name: 'mcp.oauth.authorize';
        outcome: 'success' | 'failure';
        errorType?: 'missing_resource' | 'invalid_resource' | 'invalid_site' | 'site_not_enabled' | 'invalid_client';
    } | {
        name: 'mcp.oauth.register';
        outcome: 'success' | 'failure';
        errorType?: 'rate_limited' | 'invalid_redirect_uri' | 'validation_error';
    } | {
        name: 'auth.apiKey.mint';
        outcome: 'success' | 'failure';
    } | {
        name: 'auth.apiKey.revoke';
        outcome: 'success' | 'failure';
    } | {
        name: 'auth.apiKey.exchange';
        outcome: 'attempt' | 'success' | 'failure' | 'cache_hit';
        errorType?: 'corrupt_cache' | 'cache_parse_error' | 'network_error' | 'auth0_rejected' | 'response_parse_error' | 'missing_access_token' | 'cache_write_error';
    } | {
        name: 'auth.apiKey.verify';
        outcome: 'attempt' | 'success' | 'failure';
        errorType?: 'missing_signature' | 'expired_signature' | 'invalid_signature';
    } | {
        /**
         * Emitted when an MCP block renderer or page/pattern formatter
         * produces no meaningful output (unhandled block type, missing
         * data, or not-found entity). Used to track coverage gaps in the
         * MCP block renderer without leaking customer content.
         */
        name: 'mcp.block.empty';
        toolName: string;
        blockType: string;
        reason: 'unhandled-block-type' | 'missing-data' | 'page-not-found' | 'pattern-not-found' | 'pattern-spec-not-found';
        parentType?: 'page' | 'pattern' | 'document' | 'component';
        parentId?: string;
        templateId?: string;
    } | {
        name: 'mcp.distro.resolve.memory' | 'mcp.distro.resolve.r2';
        outcome: 'hit' | 'miss';
    } | {
        name: 'mcp.distro.resolve.upgrade';
        outcome: 'success' | 'failure';
        errorType?: 'permission_denied';
    } | {
        name: 'mcp.distro.resolve.fetch' | 'mcp.distro.resolve.unzip' | 'mcp.distro.resolve.store' | 'mcp.distro.resolve.complete';
    } | {
        name: 'mcp.distro.revalidate.check';
        outcome: 'changed' | 'error';
    } | {
        name: 'lambda.nativeComponentUploadHandler.s3event';
        siteId: string;
        rendererId: RendererIdsForNativeMobile;
        key: string;
        bucket: string;
    } | {
        name: 'lambda.nativeComponentUploadHandler.componentCached';
        siteId: string;
        rendererId: RendererIdsForNativeMobile;
        component: string;
    } | {
        name: 'lambda.nativeComponentUploadHandler.invalidKey';
        bucket: string;
        key: string;
    } | {
        name: 'lambda.nativeComponentUploadHandler.error';
        s3Key: string;
        bucket: string;
    } | {
        name: 'lambda.nativeComponentUploadHandler.missingResponseBody';
        s3Key: string;
        bucket: string;
        responseMetadata?: Record<string, any>;
    } | {
        name: 'lambda.nativeComponentUploadHandler.codeSrcsManifestUploaded';
        siteId: string;
        rendererId: RendererIdsForNativeMobile;
    } | {
        name: `lambda.contextSrcParser.${'recordStart' | 'unsupportedSourceType' | 'validationFailed' | 'recordComplete' | 'adapterError' | 'resultQueued' | 'durableMaxInvocations' | 'durableResume' | 'durableCheckpoint'}`;
        outcome: 'success' | 'failure' | null;
    } | {
        name: 'ingest.validate';
        sourceType: 'storybook' | 'mdx' | 'figma' | 'knapsack';
        outcome: 'success' | 'failure';
        errors?: string[];
    } | {
        name: 'ingest.parse';
        sourceType: 'storybook' | 'mdx' | 'figma' | 'knapsack';
        step: 'start' | 'discover' | 'extract' | 'complete';
        outcome: 'success' | 'failure' | null;
        ref?: string;
        itemCount?: number;
        durationMs?: number;
    } | {
        name: 'ingest.transform';
        sourceType: 'storybook' | 'mdx' | 'figma' | 'knapsack';
        step: 'start' | 'normalize' | 'complete';
        outcome: 'success' | 'failure' | null;
        ref?: string;
        itemCount?: number;
        durationMs?: number;
    } | {
        name: 'sourceConflicts.index';
        outcome: 'success' | 'failure';
        entityCount: number;
    } | {
        name: 'sourceConflicts.parse' | 'sourceConflicts.transform' | 'sourceConflicts.analyze';
        step: 'start' | 'complete';
        outcome: 'success' | 'failure' | null;
        itemCount?: number;
        skippedCount?: number;
        durationMs?: number;
    } | {
        name: 'sourceConflicts.item';
        ref: string;
        outcome: 'success' | 'failure';
    } | {
        name: 'ingestionHandler.invalidMessageBody' | 'ingestionHandler.jsonParseError' | 'ingestionHandler.unknownType' | 'ingestionHandler.noLambdaMapping' | 'ingestionHandler.unexpectedError';
        messageId: string;
        parserType?: string;
    } | {
        name: 'ingestionHandler.invokingParser' | 'ingestionHandler.invocationFailed' | 'ingestionHandler.routedSuccessfully';
        messageId: string;
        parserType: string;
        lambdaName: string;
        statusCode?: number;
    } | {
        name: 'ingestionHandler.batchPartialFailure';
        failedCount: number;
        totalCount: number;
    } | {
        name: 'databaseHandler.invalidMessage' | 'databaseHandler.unexpectedError';
        messageId: string;
    } | {
        name: 'databaseHandler.processing' | 'databaseHandler.persistFailed' | 'databaseHandler.persisted';
        messageId: string;
        jobId: string;
        sourceType: string;
        status?: string;
    } | {
        name: 'databaseHandler.batchPartialFailure';
        failedCount: number;
        totalCount: number;
    } | {
        name: 'databaseHandler.distroBuildTriggered' | 'databaseHandler.distroBuildInvocationFailed' | 'databaseHandler.distroBuildTriggerError';
        jobId: string;
        siteId: string;
        statusCode?: number;
    } | {
        name: 'distroBuildHandler.hasuraError' | 'distroBuildHandler.triggered' | 'distroBuildHandler.noDefaultChannel' | 'distroBuildHandler.noSources' | 'distroBuildHandler.mountStarted' | 'distroBuildHandler.detectStarted' | 'distroBuildHandler.buildStarted' | 'distroBuildHandler.adapterError' | 'distroBuildHandler.multipleKnapsackSources';
        [key: string]: unknown;
    } | {
        name: 'distroBuildHandler.jobCreated' | 'distroBuildHandler.sourcesDiscovered' | 'distroBuildHandler.sourceFilesDiscovered' | 'distroBuildHandler.mountComplete' | 'distroBuildHandler.detectComplete' | 'distroBuildHandler.uploadComplete' | 'distroBuildHandler.complete' | 'distroBuildHandler.failed';
        [key: string]: unknown;
    } | {
        name: 'api.contextSource.create' | 'api.contextSource.delete' | 'api.contextSource.update' | 'api.contextSource.refresh' | 'api.contextSource.replace' | 'api.contextSource.completeUpload' | 'api.contextSource.retry';
        outcome: 'success' | 'failure';
        sourceType?: string;
        intent?: string;
    } | {
        name: 'api.contextSource.deploy';
        outcome: 'success' | 'failure';
        action: 'create' | 'refresh' | 'skip';
    } | {
        name: 'api.contextSource.enrich';
        outcome: 'success' | 'failure';
    } | {
        name: 'api.ipe.enqueue';
        outcome: 'success' | 'failure';
        sourceType?: string;
    } | {
        name: 'api.ipe.activate';
        outcome: 'success' | 'failure';
    };
    knapsackMeta?: KsLogMeta;
    metadata?: {
        [key: string]: unknown;
    };
};
export type LogMetadataFull = LogMetadata & {
    status: 'info' | 'warn' | 'debug' | 'error';
    message: string;
};
//# sourceMappingURL=log.types.d.cts.map