@castleio/sdk 2.3.1 → 3.0.0

package/dist/index.d.ts

@@ -1,8 +1,966 @@
-export { Castle } from './src/Castle';
-export { ConfigurationProperties as CastleConfiguration } from './src/configuration';
-export * from './src/constants';
-export * from './src/models';
-export * from './src/errors';
-export * from './src/failover/failover.module';
-export * from './src/payload/payload.module';
-export { ContextPrepareService } from './src/context/context.module';
+import { IncomingHttpHeaders } from 'http2';
+import { Request } from 'express';
+
+type AddressPayload = {
+    country_code: string;
+    line1?: string;
+    line2?: string;
+    city?: string;
+    region_code?: string;
+    postal_code?: string;
+    fingerprint?: string;
+};
+
+type TransactionAmountPayload = {
+    type: '$fiat' | '$crypto';
+    value?: string;
+    currency?: string;
+    [key: string]: any;
+};
+type PaymentMethodPayload = {
+    type: string;
+    fingerprint?: string;
+    holder_name?: string;
+    bank_name?: string;
+    country_code?: string;
+    billing_address?: AddressPayload;
+    card?: {
+        bin?: string;
+        last4?: string;
+        exp_month?: number;
+        exp_year?: number;
+        network?: string;
+        funding?: string;
+        [key: string]: any;
+    };
+    [key: string]: any;
+};
+type MerchantPayload = {
+    id?: string;
+    name?: string;
+    category?: {
+        code?: string;
+        description?: string;
+        [key: string]: any;
+    };
+    address?: AddressPayload;
+    [key: string]: any;
+};
+type TransactionPayload = {
+    id: string;
+    type: string;
+    base_amount?: string;
+    amount?: TransactionAmountPayload;
+    payment_method?: PaymentMethodPayload;
+    shipping_address?: AddressPayload;
+    merchant?: MerchantPayload;
+    [key: string]: any;
+};
+type BaseRiskPayload = {
+    user: {
+        id: string;
+        phone?: string;
+        email?: string;
+        registered_at?: string;
+        traits?: {
+            [key: string]: any;
+        };
+        name?: string;
+        address?: AddressPayload;
+    };
+    properties?: {
+        [key: string]: any;
+    };
+    created_at?: string;
+    product?: {
+        id: string;
+    };
+    session?: {
+        id: string;
+        created_at?: string;
+    };
+    authentication_method?: {
+        type: string;
+        variant?: string;
+        email?: string;
+        phone?: string;
+    };
+    status?: string;
+    name?: string;
+    address?: AddressPayload;
+    transaction?: TransactionPayload;
+    skip_request_token_validation?: boolean;
+    skip_context_validation?: boolean;
+} & ({
+    event: string;
+} | {
+    type: string;
+});
+type Context$1 = {
+    ip: string;
+    headers: IncomingHttpHeaders | {
+        [key: string]: string | boolean;
+    };
+};
+type RequiredContextAndToken$1 = BaseRiskPayload & {
+    request_token: string;
+    context: Context$1;
+    skip_request_token_validation?: false;
+    skip_context_validation?: false;
+};
+type SkipRequestToken$1 = BaseRiskPayload & {
+    request_token?: string;
+    context: Context$1;
+    skip_request_token_validation: true;
+    skip_context_validation?: false;
+};
+type SkipContext$1 = BaseRiskPayload & {
+    request_token: string;
+    context?: Context$1;
+    skip_request_token_validation?: false;
+    skip_context_validation: true;
+};
+type SkipBoth$1 = BaseRiskPayload & {
+    request_token?: string;
+    context?: Context$1;
+    skip_request_token_validation: true;
+    skip_context_validation: true;
+};
+type RiskPayload = RequiredContextAndToken$1 | SkipRequestToken$1 | SkipContext$1 | SkipBoth$1;
+
+type BaseFilterPayload = {
+    user?: {
+        email?: string;
+        phone?: string;
+    };
+    matching_user_id?: string;
+    params?: {
+        email?: string;
+        phone?: string;
+        username?: string;
+    };
+    properties?: {
+        [key: string]: any;
+    };
+    product?: {
+        id: string;
+    };
+    session?: {
+        id: string;
+        created_at?: string;
+    };
+    created_at?: string;
+    authentication_method?: {
+        type: string;
+        variant?: string;
+        email?: string;
+        phone?: string;
+    };
+    status?: string;
+    name?: string;
+    transaction?: TransactionPayload;
+} & ({
+    event: string;
+} | {
+    type: string;
+});
+type Context = {
+    ip: string;
+    headers: IncomingHttpHeaders | {
+        [key: string]: string | boolean;
+    };
+};
+type RequiredContextAndToken = BaseFilterPayload & {
+    request_token: string;
+    context: Context;
+    skip_request_token_validation?: false;
+    skip_context_validation?: false;
+};
+type SkipRequestToken = BaseFilterPayload & {
+    request_token?: string;
+    context: Context;
+    skip_request_token_validation: true;
+    skip_context_validation?: false;
+};
+type SkipContext = BaseFilterPayload & {
+    request_token: string;
+    context?: Context;
+    skip_request_token_validation?: false;
+    skip_context_validation: true;
+};
+type SkipBoth = BaseFilterPayload & {
+    request_token?: string;
+    context?: Context;
+    skip_request_token_validation: true;
+    skip_context_validation: true;
+};
+type FilterPayload = RequiredContextAndToken | SkipRequestToken | SkipContext | SkipBoth;
+
+type LogPayload = {
+    request_token?: string;
+    user?: {
+        id?: string;
+        phone?: string;
+        email?: string;
+        registered_at?: string;
+        traits?: {
+            [key: string]: any;
+        };
+        name?: string;
+        address?: AddressPayload;
+    };
+    created_at?: string;
+    properties?: {
+        [key: string]: any;
+    };
+    context?: {
+        ip?: string;
+        headers: IncomingHttpHeaders | {
+            [key: string]: string | boolean;
+        };
+    };
+    product?: any;
+    session?: {
+        id: string;
+        created_at?: string;
+    };
+    authentication_method?: {
+        type: string;
+        variant?: string;
+        email?: string;
+        phone?: string;
+    };
+    status?: string;
+    transaction?: TransactionPayload;
+} & ({
+    event: string;
+} | {
+    type: string;
+});
+
+type ListItemAuthorType = '$analyst_email' | '$castle_dashboard_user' | '$castle_policy' | '$user' | '$user_email' | '$other';
+type ListItemMode = '$error' | '$replace' | '$update' | '$update_or_replace';
+type ListItemPayload = {
+    id: string;
+    list_id: string;
+};
+type FullListItemPayload = {
+    primary_value: string;
+    author: {
+        type: ListItemAuthorType;
+        identifier: string;
+    };
+    secondary_value?: string;
+    comment?: string;
+    auto_archives_at?: string;
+    mode?: ListItemMode;
+};
+type CreateListItemPayload = {
+    list_id: string;
+} & FullListItemPayload;
+type UpdateListItemPayload = ListItemPayload & {
+    comment: string;
+};
+type SearchListItemsPayload = {
+    list_id: string;
+    sort?: {
+        field: string;
+        order: string;
+    };
+    filters?: any[];
+    page?: number;
+    results_size?: number;
+};
+type BatchUpsertListItemsPayload = {
+    list_id: string;
+    items: FullListItemPayload[];
+};
+type CountListItemsPayload = {
+    list_id: string;
+    filters?: {
+        field: string;
+        op: string;
+        value: string | boolean;
+    }[];
+};
+
+type ListPayload = {
+    id: string;
+};
+type CreateListPayload = {
+    name: string;
+    color: string;
+    primary_field: string;
+    description?: string;
+    secondary_field?: string;
+    default_item_archivation_time?: null | number;
+};
+type UpdateListPayload = ListPayload & {
+    name?: string;
+    color?: string;
+    description?: string;
+    default_item_archivation_time?: null | number;
+};
+type SearchListsPayload = {
+    sort?: {
+        field: string;
+        order: string;
+    };
+    filters?: any[];
+    page?: number;
+    results_size?: number;
+};
+
+type SearchEventsPayload = {
+    filters: Array<SearchEventsQueryFilter | SearchEventsRelativeRangeQueryFilter | SearchEventsRangeQueryFilter | SearchEventsExistsQueryFilter | SearchEventsOrQueryFilter>;
+    query_type?: SearchEventsQueryType;
+    page?: number;
+    columns?: Array<string>;
+    results_size?: number;
+};
+declare enum SearchEventsQueryType {
+    COUNT = "$count",
+    RECORDS = "$records",
+    RECORDS_WITH_COUNT = "$records_with_count"
+}
+type SearchEventsQueryFilter = {
+    field: string;
+    op: SearchEventsQueryFilterOperator;
+    value: string | number | boolean | Array<string> | Array<number> | {
+        reference: string;
+    };
+};
+declare enum SearchEventsQueryFilterOperator {
+    IN = "$in",
+    NIN = "$nin",
+    EQ = "$eq",
+    NEQ = "$neq",
+    LIKE = "$like",
+    NLIKE = "$nlike",
+    CONTAINS = "$contains",
+    NCONTAINS = "$ncontains",
+    STARTS_WITH = "$starts_with",
+    NSTARTS_WITH = "$nstarts_with",
+    ENDS_WITH = "$ends_with",
+    NENDS_WITH = "$nends_with",
+    MATCHES = "$matches",
+    NMATCHES = "$nmatches",
+    IP_RANGE = "$ip_range",
+    NIP_RANGE = "$nip_range"
+}
+type SearchEventsRelativeRangeQueryFilter = {
+    field: string;
+    op: '$relative_range';
+    value: {
+        gteq?: number;
+        gt?: number;
+        lteq?: number;
+        lt?: number;
+    };
+};
+type SearchEventsRangeQueryFilter = {
+    field: string;
+    op: '$range';
+    value: {
+        gteq?: string | number;
+        gt?: string | number;
+        lteq?: string | number;
+        lt?: string | number;
+    };
+};
+type SearchEventsExistsQueryFilter = {
+    field: string;
+    op: '$exists' | '$nexists';
+};
+type SearchEventsOrQueryFilter = {
+    value: Array<SearchEventsQueryFilter | SearchEventsRelativeRangeQueryFilter | SearchEventsRangeQueryFilter | SearchEventsExistsQueryFilter>;
+    op: '$or';
+};
+type GroupEventsPayload = {
+    filters: any[];
+    group_by: {
+        fields: any[];
+        filters?: any[];
+    };
+    columns: any[];
+    query_type?: string;
+    page?: number;
+    aggregations?: any[];
+    formulas?: any[];
+    having?: any[];
+    sort?: {
+        field: string;
+        func: string;
+        transform?: {
+            transform: string;
+            options: object;
+        };
+        options?: object;
+        order?: 'asc' | 'desc';
+    };
+    results_size?: number;
+};
+
+type SearchEventsResponse = {
+    data: Event[];
+    total_count: number;
+};
+type Event = {
+    id: string;
+    type: string;
+    status: string;
+    risk: number | null;
+    signals: Array<EventSignal>;
+    properties: Record<string, string | number | boolean | object | Array<string> | Array<string | number | boolean>>;
+    product: {
+        id: string;
+    };
+    device: {
+        fingerprint: string;
+        user_agent?: string;
+        hardware?: {
+            type: string;
+            name: string | null;
+            brand: string | null;
+            display: {
+                width: number;
+                height: number;
+            };
+            model?: {
+                name: string | null;
+                code: string | null;
+            };
+        };
+        os?: {
+            name: string;
+            version: {
+                major: string;
+                full: string | null;
+            };
+        };
+        software?: {
+            type: string;
+            name: string;
+            languages: Array<string>;
+            version: {
+                major: string;
+                full: string;
+            };
+            fingerprint: string;
+        };
+        timezone?: {
+            offset?: number;
+            name?: string;
+        };
+        screen?: {
+            screen?: number;
+            orientation?: string;
+        };
+    };
+    ip: {
+        asn: number;
+        location: {
+            city: string;
+            continent_code: string;
+            country_code: string;
+            postal_code: string;
+            region_code: string;
+            latitude: number;
+            longitude: number;
+        };
+        address: string;
+        isp: {
+            name?: string;
+            organization?: string;
+        };
+        type: string;
+        privacy?: {
+            anonymous?: boolean;
+            datacenter?: boolean;
+            proxy?: boolean;
+            tor?: boolean;
+        };
+    };
+    policy: {
+        name: string;
+        id: string;
+        revision_id: string | null;
+        action: string | null;
+        response?: {
+            status_code: number;
+            body: string;
+            headers: Array<{
+                name?: string;
+                value?: string;
+            }>;
+        } | null;
+    };
+    user: {
+        id: string;
+        registered_at: string;
+        last_seen_at: string;
+        risk: number | null;
+        devices_count: number | null;
+        name: string | null;
+        email: string | null;
+        phone: string | null;
+        traits?: Record<string, string | number | boolean | object>;
+        address?: {
+            country_code: string;
+            line1?: string;
+            line2?: string;
+            city?: string;
+            region_code?: string;
+            postal_code?: string;
+            fingerprint?: string;
+        };
+    };
+    created_at: string;
+    params?: {
+        email?: string;
+        phone?: string;
+        username?: string;
+    };
+    transaction?: {
+        type: string;
+        id: string;
+        base_amount?: string;
+        amount?: {
+            type: string;
+            value: string;
+            currency: string;
+        };
+        payment_method?: {
+            type: string;
+            fingerprint?: string;
+            holder_name?: string;
+            bank_name?: string;
+            country_code?: string;
+            billing_address?: {
+                line1?: string;
+                line2?: string;
+                city?: string;
+                country_code?: string;
+                region_code?: string;
+                postal_code?: string;
+                fingerprint?: string;
+            };
+            card?: {
+                bin?: string;
+                last4?: string;
+                exp_month?: number;
+                exp_year?: number;
+                network?: string;
+                funding?: string;
+            };
+        };
+        shipping_address?: {
+            country_code: string;
+            line1?: string;
+            line2?: string;
+            city?: string;
+            region_code?: string;
+            postal_code?: string;
+            fingerprint?: string;
+        };
+        merchant?: {
+            id?: string;
+            name?: string;
+            category?: {
+                code?: string;
+                description?: string;
+            };
+            address?: {
+                country_code: string;
+                line1?: string;
+                line2?: string;
+                city?: string;
+                region_code?: string;
+                postal_code?: string;
+                fingerprint?: string;
+            };
+        };
+    };
+    authentication_method?: {
+        type: EventAuthenticationMethod;
+        variant?: string;
+        email?: string;
+        phone?: string;
+    };
+    page?: {
+        name: string;
+        url: string;
+        referrer?: string;
+    };
+    screen?: {
+        name: string;
+    };
+    scores?: {
+        account_sharing?: {
+            score: number;
+        };
+        account_takeover?: {
+            score: number;
+        };
+        bot?: {
+            score: number;
+        };
+        multi_accounting?: {
+            score: number;
+        };
+        spoofed_device?: {
+            score: number;
+        };
+        spoofed_location?: {
+            score: number;
+        };
+        unified?: {
+            score: number;
+        };
+    };
+    changeset?: {
+        [key: string]: {
+            changed: boolean;
+        };
+    } | {
+        from: string | null;
+        to: string | null;
+    };
+};
+declare enum EventSignal {
+    ABUSE_IP = "abuse_ip",
+    BOT_BEHAVIOR = "bot_behavior",
+    CREDENTIAL_STUFFING = "credential_stuffing",
+    DISPOSABLE_EMAIL_DOMAIN = "disposable_email_domain",
+    GENERATED_EMAIL = "generated_email",
+    HEADLESS_BROWSER = "headless_browser",
+    HTTP_CLIENT_LIBRARY = "http_client_library",
+    IMPOSSIBLE_TRAVEL = "impossible_travel",
+    INVALID_EMAIL = "invalid_email",
+    INVALID_DEVICE_DATA = "invalid_device_data",
+    MISSING_DEVICE_DATA = "missing_device_data",
+    MISSING_HEADERS = "missing_headers",
+    MULTIPLE_ACCOUNTS_PER_DEVICE = "multiple_accounts_per_device",
+    MULTIPLE_ALIASES_PER_EMAIL = "multiple_aliases_per_email",
+    NEW_COUNTRY = "new_country",
+    NEW_DEVICE = "new_device",
+    NEW_DEVICE_TYPE = "new_device_type",
+    NEW_ISP = "new_isp",
+    NEW_LANGUAGE = "new_language",
+    NEW_OS = "new_os",
+    HIGH_ACTIVITY_DEVICE = "high_activity_device",
+    HIGH_ACTIVITY_IP = "high_activity_ip",
+    HIGH_ACTIVITY_ACCOUNT = "high_activity_account",
+    SPOOFED_DEVICE = "spoofed_device",
+    WEB_CRAWLER = "web_crawler"
+}
+declare enum EventAuthenticationMethod {
+    AUTHENTICATOR = "$authenticator",
+    BIOMETRICS = "$biometrics",
+    EMAIL = "$email",
+    PASSWORD = "$password",
+    PHONE = "$phone",
+    PUSH = "$push",
+    SECURITY_KEY = "$security_key",
+    SOCIAL = "$social",
+    SSO = "$sso",
+    KBA = "$kba",
+    ELECTRONIC_ID = "$electronic_id",
+    PHYSICAL_ID = "$physical_id",
+    DOCUMENT = "$document",
+    VIDEO = "$video",
+    PASSKEY = "$passkey",
+    OTHER = "$other"
+}
+type Op = '$eq' | '$neq' | '$in' | '$nin' | '$range' | '$exists' | '$nexists' | '$geo' | '$like' | '$nlike' | '$contains' | '$ncontains' | '$starts_with' | '$nstarts_with' | '$ends_with' | '$nends_with' | '$ip_range' | '$nip_range';
+type Func = '$sum' | '$last' | '$avg' | '$min' | '$max' | '$count' | '$top_k' | '$date_histogram' | '$count_unique';
+type DataType = 'array' | 'boolean' | 'datetime' | 'decimal' | 'integer' | 'ip' | 'map' | 'number' | 'string' | 'uuid';
+type Transform = '$to_end_of_interval';
+type NumberLike = number | string;
+type Source = 'ios' | 'android' | 'web';
+type SearchField = {
+    field: string;
+    op: Op[];
+    func: Func[];
+    type: DataType[];
+    nice_name: string;
+    description: string;
+    transform?: Transform[];
+    min?: NumberLike;
+    max?: NumberLike;
+    source?: Source[];
+    example?: string;
+    unit?: string;
+};
+type CountBucket = {
+    name: string;
+    field: string;
+    type: '$count';
+    options?: {
+        size?: {
+            data_type: string;
+        };
+    };
+};
+type DateHistogramBucket = {
+    name: string;
+    field: string;
+    type: '$date_histogram';
+    options: {
+        interval: {
+            required: boolean;
+            data_type: string;
+            enum: string;
+        };
+        time_zone: string;
+        min?: {
+            data_type: string;
+            format?: string[];
+        };
+        max?: {
+            data_type: string;
+            format?: string[];
+        };
+        size: {
+            data_type: string;
+        };
+    };
+};
+type RangeBucket = {
+    name: string;
+    field: string;
+    type: '$range';
+    options: {
+        ranges: {
+            required: boolean;
+            data_type: 'string' | 'number';
+        };
+    };
+};
+type Bucket = CountBucket | DateHistogramBucket | RangeBucket;
+type GetEventsSchemaResponse = {
+    fields: SearchField[];
+    buckets: Bucket[];
+};
+type GroupEventsResponse = {
+    data: GroupEvent[];
+    total_count: number;
+};
+type GroupEvent = object;
+
+type RequestUserDataPayload = {
+    identifier: string;
+    identifier_type: '$id' | '$email';
+};
+type DeleteUserDataPayload = {
+    identifier: string;
+    identifier_type: '$id' | '$email';
+};
+
+declare enum FailoverStrategy {
+    allow = "allow",
+    deny = "deny",
+    challenge = "challenge",
+    throw = "throw"
+}
+
+interface ConfigurationProperties {
+    apiSecret: string;
+    baseUrl?: string;
+    timeout?: number;
+    allowlisted?: string[];
+    denylisted?: string[];
+    overrideFetch?: any;
+    failoverStrategy?: FailoverStrategy;
+    doNotTrack?: boolean;
+    ipHeaders?: string[];
+    trustedProxies?: (string | RegExp)[];
+    trustProxyChain?: boolean;
+    trustedProxyDepth?: number;
+    logger?: any;
+}
+declare class Configuration {
+    apiSecret: string;
+    baseUrl: URL;
+    timeout: number;
+    allowlisted: string[];
+    denylisted: string[];
+    overrideFetch: any;
+    failoverStrategy: FailoverStrategy;
+    doNotTrack: boolean;
+    ipHeaders: string[];
+    trustedProxies: RegExp[];
+    trustProxyChain: boolean;
+    trustedProxyDepth: number;
+    logger: any;
+    constructor({ apiSecret, baseUrl, timeout, allowlisted, denylisted, overrideFetch, failoverStrategy, doNotTrack, ipHeaders, trustedProxies, trustProxyChain, trustedProxyDepth, logger, }: ConfigurationProperties);
+}
+
+declare const PayloadPrepareService: {
+    call: (payloadParams: {
+        [key: string]: any;
+    }, request: Request, configuration: Configuration, options?: {
+        [key: string]: any;
+    }) => any;
+};
+
+declare class Castle {
+    configuration: Configuration;
+    constructor(configAttributes: ConfigurationProperties);
+    risk(params: RiskPayload): Promise<object>;
+    filter(params: FilterPayload): Promise<object>;
+    log(params: LogPayload): Promise<void>;
+    createListItem(params: CreateListItemPayload): Promise<any>;
+    createList(params: CreateListPayload): Promise<any>;
+    updateListItem(params: UpdateListItemPayload): Promise<any>;
+    updateList(params: UpdateListPayload): Promise<any>;
+    archiveListItem(params: ListItemPayload): Promise<any>;
+    unarchiveListItem(params: ListItemPayload): Promise<any>;
+    deleteList(params: ListPayload): Promise<any>;
+    fetchListItem(params: ListItemPayload): Promise<any>;
+    fetchList(params: ListPayload): Promise<any>;
+    fetchAllLists(): Promise<any>;
+    searchListItems(params: SearchListItemsPayload): Promise<any>;
+    searchLists(params: SearchListsPayload): Promise<any>;
+    batchUpdateListItems(params: BatchUpsertListItemsPayload): Promise<any>;
+    countListItems(params: CountListItemsPayload): Promise<any>;
+    queryEvents(params: SearchEventsPayload): Promise<SearchEventsResponse>;
+    eventsSchema(): Promise<GetEventsSchemaResponse>;
+    groupEvents(params: GroupEventsPayload): Promise<GroupEventsResponse>;
+    searchEvents(params: SearchEventsPayload): Promise<SearchEventsResponse>;
+    getEventsSchema(): Promise<GetEventsSchemaResponse>;
+    requestUserData(params: RequestUserDataPayload): Promise<any>;
+    deleteUserData(params: DeleteUserDataPayload): Promise<any>;
+    verifyWebhookSignature(payload: string | Buffer, signature: string | undefined): void;
+    secureModeSignature(userId: string): string;
+    private generateDoNotTrackResponse;
+}
+
+declare const DEFAULT_API_URL = "https://api.castle.io/v1";
+declare const DEFAULT_TIMEOUT = 1500;
+declare const DEFAULT_ALLOWLIST: string[];
+declare const TRUSTED_PROXIES: RegExp[];
+
+interface RiskPolicy {
+    id: string;
+    revision_id: string;
+    name: string;
+    action: string | null | undefined;
+}
+interface RiskPolicyFailover {
+    action: string | null | undefined;
+}
+
+interface Signals {
+    [name: string]: any;
+}
+
+interface Device {
+    token: string;
+}
+
+declare enum EventType {
+    CHALLENGE = "$challenge",
+    CUSTOM = "$custom",
+    LOGIN = "$login",
+    LOGOUT = "$logout",
+    PASSWORD_RESET_REQUEST = "$password_reset_request",
+    PROFILE_RESET = "$profile_reset",
+    PROFILE_UPDATE = "$profile_update",
+    REGISTRATION = "$registration",
+    TRANSACTION = "$transaction"
+}
+declare enum EventStatus {
+    ATTEMPTED = "$attempted",
+    FAILED = "$failed",
+    REQUESTED = "$requested",
+    SUCCEEDED = "$succeeded"
+}
+
+interface ListItem {
+    id: string;
+    list_id: string;
+    primary_value: string;
+    secondary_value?: string;
+    comment?: string;
+    author?: {
+        type: ListItemAuthorType;
+        identifier: string;
+    };
+    auto_archives_at?: string;
+    archived?: boolean;
+    created_at?: string;
+}
+
+interface List {
+    id: string;
+    name: string;
+    color: string;
+    primary_field: string;
+    description?: string;
+    secondary_field?: string;
+    default_item_archivation_time?: null | number;
+    archived_at?: string;
+    created_at?: string;
+}
+
+declare enum Action {
+    allow = "allow",
+    deny = "deny",
+    challenge = "challenge"
+}
+
+declare class ConfigurationError extends Error {
+    constructor(message: string);
+}
+declare class APIError extends Error {
+    constructor(message: string);
+}
+declare class BadRequestError extends APIError {
+    constructor(message: string);
+}
+declare class UnauthorizedError extends APIError {
+    constructor(message: string);
+}
+declare class ForbiddenError extends APIError {
+    constructor(message: string);
+}
+declare class NotFoundError extends APIError {
+    constructor(message: string);
+}
+declare class UserUnauthorizedError extends APIError {
+    constructor(message: string);
+}
+declare class InvalidParametersError extends APIError {
+    constructor(message: string);
+}
+declare class InvalidRequestTokenError extends InvalidParametersError {
+    constructor(message: string);
+}
+declare class RateLimitError extends APIError {
+    constructor(message: string);
+}
+declare class InternalServerError extends APIError {
+    constructor(message: string);
+}
+declare class WebhookVerificationError extends Error {
+    constructor(message: string);
+}
+
+declare const ContextPrepareService: {
+    call: (request: {
+        headers: IncomingHttpHeaders;
+    }, options: undefined | {
+        [key: string]: any;
+    }, configuration: Configuration) => any;
+};
+
+declare const WebhookVerifyService: {
+    call: (payload: string | Buffer, signature: string | undefined, configuration: Configuration) => void;
+};
+
+declare const SecureModeService: {
+    call: (userId: string, configuration: Configuration) => string;
+};
+
+export { APIError, Action, type AddressPayload, BadRequestError, type BatchUpsertListItemsPayload, type Bucket, Castle, type ConfigurationProperties as CastleConfiguration, ConfigurationError, ContextPrepareService, type CountBucket, type CountListItemsPayload, type CreateListItemPayload, type CreateListPayload, DEFAULT_ALLOWLIST, DEFAULT_API_URL, DEFAULT_TIMEOUT, type DataType, type DateHistogramBucket, type DeleteUserDataPayload, type Device, type Event, EventAuthenticationMethod, EventSignal, EventStatus, EventType, FailoverStrategy, type FilterPayload, ForbiddenError, type FullListItemPayload, type Func, type GetEventsSchemaResponse, type GroupEvent, type GroupEventsPayload, type GroupEventsResponse, InternalServerError, InvalidParametersError, InvalidRequestTokenError, type List, type ListItem, type ListItemAuthorType, type ListItemMode, type ListItemPayload, type ListPayload, type LogPayload, NotFoundError, type NumberLike, type Op, PayloadPrepareService, type RangeBucket, RateLimitError, type RequestUserDataPayload, type RiskPayload, type RiskPolicy, type RiskPolicyFailover, type SearchEventsExistsQueryFilter, type SearchEventsOrQueryFilter, type SearchEventsPayload, type SearchEventsQueryFilter, SearchEventsQueryFilterOperator, SearchEventsQueryType, type SearchEventsRangeQueryFilter, type SearchEventsRelativeRangeQueryFilter, type SearchEventsResponse, type SearchField, type SearchListItemsPayload, type SearchListsPayload, SecureModeService, type Signals, type Source, TRUSTED_PROXIES, type TransactionPayload, type Transform, UnauthorizedError, type UpdateListItemPayload, type UpdateListPayload, UserUnauthorizedError, WebhookVerificationError, WebhookVerifyService };