@openrouter/sdk 0.11.2 → 0.12.1

package/esm/models/operations/createguardrail.js

@@ -4,101 +4,20 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
-import * as openEnums from "../../types/enums.js";
-/**
- * Interval at which the limit resets (daily, weekly, monthly)
- */
-export const CreateGuardrailResetIntervalRequest = {
-    Daily: "daily",
-    Weekly: "weekly",
-    Monthly: "monthly",
-};
-/**
- * Interval at which the limit resets (daily, weekly, monthly)
- */
-export const CreateGuardrailResetIntervalResponse = {
-    Daily: "daily",
-    Weekly: "weekly",
-    Monthly: "monthly",
-};
-/** @internal */
-export const CreateGuardrailResetIntervalRequest$outboundSchema = openEnums.outboundSchema(CreateGuardrailResetIntervalRequest);
-/** @internal */
-export const CreateGuardrailRequestBody$outboundSchema = z.object({
-    name: z.string(),
-    description: z.nullable(z.string()).optional(),
-    limitUsd: z.nullable(z.number()).optional(),
-    resetInterval: z.nullable(CreateGuardrailResetIntervalRequest$outboundSchema)
-        .optional(),
-    allowedProviders: z.nullable(z.array(z.string())).optional(),
-    ignoredProviders: z.nullable(z.array(z.string())).optional(),
-    allowedModels: z.nullable(z.array(z.string())).optional(),
-    enforceZdr: z.nullable(z.boolean()).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        limitUsd: "limit_usd",
-        resetInterval: "reset_interval",
-        allowedProviders: "allowed_providers",
-        ignoredProviders: "ignored_providers",
-        allowedModels: "allowed_models",
-        enforceZdr: "enforce_zdr",
-    });
-});
-export function createGuardrailRequestBodyToJSON(createGuardrailRequestBody) {
-    return JSON.stringify(CreateGuardrailRequestBody$outboundSchema.parse(createGuardrailRequestBody));
-}
+import * as models from "../index.js";
 /** @internal */
 export const CreateGuardrailRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
-    requestBody: z.lazy(() => CreateGuardrailRequestBody$outboundSchema),
+    createGuardrailRequest: models.CreateGuardrailRequest$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
-        requestBody: "RequestBody",
+        createGuardrailRequest: "CreateGuardrailRequest",
     });
 });
 export function createGuardrailRequestToJSON(createGuardrailRequest) {
     return JSON.stringify(CreateGuardrailRequest$outboundSchema.parse(createGuardrailRequest));
 }
-/** @internal */
-export const CreateGuardrailResetIntervalResponse$inboundSchema = openEnums.inboundSchema(CreateGuardrailResetIntervalResponse);
-/** @internal */
-export const CreateGuardrailData$inboundSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    description: z.nullable(z.string()).optional(),
-    limit_usd: z.nullable(z.number()).optional(),
-    reset_interval: z.nullable(CreateGuardrailResetIntervalResponse$inboundSchema)
-        .optional(),
-    allowed_providers: z.nullable(z.array(z.string())).optional(),
-    ignored_providers: z.nullable(z.array(z.string())).optional(),
-    allowed_models: z.nullable(z.array(z.string())).optional(),
-    enforce_zdr: z.nullable(z.boolean()).optional(),
-    created_at: z.string(),
-    updated_at: z.nullable(z.string()).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        "limit_usd": "limitUsd",
-        "reset_interval": "resetInterval",
-        "allowed_providers": "allowedProviders",
-        "ignored_providers": "ignoredProviders",
-        "allowed_models": "allowedModels",
-        "enforce_zdr": "enforceZdr",
-        "created_at": "createdAt",
-        "updated_at": "updatedAt",
-    });
-});
-export function createGuardrailDataFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => CreateGuardrailData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateGuardrailData' from JSON`);
-}
-/** @internal */
-export const CreateGuardrailResponse$inboundSchema = z.object({
-    data: z.lazy(() => CreateGuardrailData$inboundSchema),
-});
-export function createGuardrailResponseFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => CreateGuardrailResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateGuardrailResponse' from JSON`);
-}
 //# sourceMappingURL=createguardrail.js.map

package/esm/models/operations/createkeys.d.ts

@@ -37,25 +37,29 @@ export declare const CreateKeysLimitReset: {
 export type CreateKeysLimitReset = OpenEnum<typeof CreateKeysLimitReset>;
 export type CreateKeysRequestBody = {
     /**
-     * Name for the new API key
+     * Optional user ID of the key creator. Only meaningful for organization-owned keys where a specific member is creating the key.
      */
-    name: string;
+    creatorUserId?: string | null | undefined;
+    /**
+     * Optional ISO 8601 UTC timestamp when the API key should expire. Must be UTC, other timezones will be rejected
+     */
+    expiresAt?: Date | null | undefined;
+    /**
+     * Whether to include BYOK usage in the limit
+     */
+    includeByokInLimit?: boolean | undefined;
     /**
      * Optional spending limit for the API key in USD
      */
-    limit?: number | null | undefined;
+    limit?: number | undefined;
     /**
      * Type of limit reset for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
      */
     limitReset?: CreateKeysLimitReset | null | undefined;
     /**
-     * Whether to include BYOK usage in the limit
-     */
-    includeByokInLimit?: boolean | undefined;
-    /**
-     * Optional ISO 8601 UTC timestamp when the API key should expire. Must be UTC, other timezones will be rejected
+     * Name for the new API key
      */
-    expiresAt?: Date | null | undefined;
+    name: string;
 };
 export type CreateKeysRequest = {
     /**
@@ -84,85 +88,85 @@ export type CreateKeysRequest = {
  */
 export type CreateKeysData = {
     /**
-     * Unique hash identifier for the API key
+     * Total external BYOK usage (in USD) for the API key
      */
-    hash: string;
+    byokUsage: number;
     /**
-     * Name of the API key
+     * External BYOK usage (in USD) for the current UTC day
      */
-    name: string;
+    byokUsageDaily: number;
     /**
-     * Human-readable label for the API key
+     * External BYOK usage (in USD) for current UTC month
      */
-    label: string;
+    byokUsageMonthly: number;
     /**
-     * Whether the API key is disabled
+     * External BYOK usage (in USD) for the current UTC week (Monday-Sunday)
      */
-    disabled: boolean;
+    byokUsageWeekly: number;
     /**
-     * Spending limit for the API key in USD
+     * ISO 8601 timestamp of when the API key was created
      */
-    limit: number | null;
+    createdAt: string;
     /**
-     * Remaining spending limit in USD
+     * The user ID of the key creator. For organization-owned keys, this is the member who created the key. For individual users, this is the user's own ID.
      */
-    limitRemaining: number | null;
+    creatorUserId: string | null;
     /**
-     * Type of limit reset for the API key
+     * Whether the API key is disabled
      */
-    limitReset: string | null;
+    disabled: boolean;
     /**
-     * Whether to include external BYOK usage in the credit limit
+     * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
      */
-    includeByokInLimit: boolean;
+    expiresAt?: Date | null | undefined;
     /**
-     * Total OpenRouter credit usage (in USD) for the API key
+     * Unique hash identifier for the API key
      */
-    usage: number;
+    hash: string;
     /**
-     * OpenRouter credit usage (in USD) for the current UTC day
+     * Whether to include external BYOK usage in the credit limit
      */
-    usageDaily: number;
+    includeByokInLimit: boolean;
     /**
-     * OpenRouter credit usage (in USD) for the current UTC week (Monday-Sunday)
+     * Human-readable label for the API key
      */
-    usageWeekly: number;
+    label: string;
     /**
-     * OpenRouter credit usage (in USD) for the current UTC month
+     * Spending limit for the API key in USD
      */
-    usageMonthly: number;
+    limit: number;
     /**
-     * Total external BYOK usage (in USD) for the API key
+     * Remaining spending limit in USD
      */
-    byokUsage: number;
+    limitRemaining: number;
     /**
-     * External BYOK usage (in USD) for the current UTC day
+     * Type of limit reset for the API key
      */
-    byokUsageDaily: number;
+    limitReset: string | null;
     /**
-     * External BYOK usage (in USD) for the current UTC week (Monday-Sunday)
+     * Name of the API key
      */
-    byokUsageWeekly: number;
+    name: string;
     /**
-     * External BYOK usage (in USD) for current UTC month
+     * ISO 8601 timestamp of when the API key was last updated
      */
-    byokUsageMonthly: number;
+    updatedAt: string | null;
     /**
-     * ISO 8601 timestamp of when the API key was created
+     * Total OpenRouter credit usage (in USD) for the API key
      */
-    createdAt: string;
+    usage: number;
     /**
-     * ISO 8601 timestamp of when the API key was last updated
+     * OpenRouter credit usage (in USD) for the current UTC day
      */
-    updatedAt: string | null;
+    usageDaily: number;
     /**
-     * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
+     * OpenRouter credit usage (in USD) for the current UTC month
      */
-    expiresAt?: Date | null | undefined;
+    usageMonthly: number;
     /**
-     * The user ID of the key creator. For organization-owned keys, this is the member who created the key. For individual users, this is the user's own ID.
+     * OpenRouter credit usage (in USD) for the current UTC week (Monday-Sunday)
      */
-    creatorUserId: string | null;
+    usageWeekly: number;
 };
 /**
  * API key created successfully
@@ -181,11 +185,12 @@ export type CreateKeysResponse = {
 export declare const CreateKeysLimitReset$outboundSchema: z.ZodType<string, CreateKeysLimitReset>;
 /** @internal */
 export type CreateKeysRequestBody$Outbound = {
-    name: string;
-    limit?: number | null | undefined;
-    limit_reset?: string | null | undefined;
-    include_byok_in_limit?: boolean | undefined;
+    creator_user_id?: string | null | undefined;
     expires_at?: string | null | undefined;
+    include_byok_in_limit?: boolean | undefined;
+    limit?: number | undefined;
+    limit_reset?: string | null | undefined;
+    name: string;
 };
 /** @internal */
 export declare const CreateKeysRequestBody$outboundSchema: z.ZodType<CreateKeysRequestBody$Outbound, CreateKeysRequestBody>;

package/esm/models/operations/createkeys.js

@@ -18,16 +18,18 @@ export const CreateKeysLimitReset = {
 export const CreateKeysLimitReset$outboundSchema = openEnums.outboundSchema(CreateKeysLimitReset);
 /** @internal */
 export const CreateKeysRequestBody$outboundSchema = z.object({
-    name: z.string(),
-    limit: z.nullable(z.number()).optional(),
-    limitReset: z.nullable(CreateKeysLimitReset$outboundSchema).optional(),
-    includeByokInLimit: z.boolean().optional(),
+    creatorUserId: z.nullable(z.string()).optional(),
     expiresAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+    includeByokInLimit: z.boolean().optional(),
+    limit: z.number().optional(),
+    limitReset: z.nullable(CreateKeysLimitReset$outboundSchema).optional(),
+    name: z.string(),
 }).transform((v) => {
     return remap$(v, {
-        limitReset: "limit_reset",
-        includeByokInLimit: "include_byok_in_limit",
+        creatorUserId: "creator_user_id",
         expiresAt: "expires_at",
+        includeByokInLimit: "include_byok_in_limit",
+        limitReset: "limit_reset",
     });
 });
 export function createKeysRequestBodyToJSON(createKeysRequestBody) {
@@ -50,42 +52,42 @@ export function createKeysRequestToJSON(createKeysRequest) {
 }
 /** @internal */
 export const CreateKeysData$inboundSchema = z.object({
+    byok_usage: z.number(),
+    byok_usage_daily: z.number(),
+    byok_usage_monthly: z.number(),
+    byok_usage_weekly: z.number(),
+    created_at: z.string(),
+    creator_user_id: z.nullable(z.string()),
+    disabled: z.boolean(),
+    expires_at: z.nullable(z.iso.datetime({ offset: true }).transform(v => new Date(v))).optional(),
     hash: z.string(),
-    name: z.string(),
+    include_byok_in_limit: z.boolean(),
     label: z.string(),
-    disabled: z.boolean(),
-    limit: z.nullable(z.number()),
-    limit_remaining: z.nullable(z.number()),
+    limit: z.number(),
+    limit_remaining: z.number(),
     limit_reset: z.nullable(z.string()),
-    include_byok_in_limit: z.boolean(),
+    name: z.string(),
+    updated_at: z.nullable(z.string()),
     usage: z.number(),
     usage_daily: z.number(),
-    usage_weekly: z.number(),
     usage_monthly: z.number(),
-    byok_usage: z.number(),
-    byok_usage_daily: z.number(),
-    byok_usage_weekly: z.number(),
-    byok_usage_monthly: z.number(),
-    created_at: z.string(),
-    updated_at: z.nullable(z.string()),
-    expires_at: z.nullable(z.iso.datetime({ offset: true }).transform(v => new Date(v))).optional(),
-    creator_user_id: z.nullable(z.string()),
+    usage_weekly: z.number(),
 }).transform((v) => {
     return remap$(v, {
-        "limit_remaining": "limitRemaining",
-        "limit_reset": "limitReset",
-        "include_byok_in_limit": "includeByokInLimit",
-        "usage_daily": "usageDaily",
-        "usage_weekly": "usageWeekly",
-        "usage_monthly": "usageMonthly",
         "byok_usage": "byokUsage",
         "byok_usage_daily": "byokUsageDaily",
-        "byok_usage_weekly": "byokUsageWeekly",
         "byok_usage_monthly": "byokUsageMonthly",
+        "byok_usage_weekly": "byokUsageWeekly",
         "created_at": "createdAt",
-        "updated_at": "updatedAt",
-        "expires_at": "expiresAt",
         "creator_user_id": "creatorUserId",
+        "expires_at": "expiresAt",
+        "include_byok_in_limit": "includeByokInLimit",
+        "limit_remaining": "limitRemaining",
+        "limit_reset": "limitReset",
+        "updated_at": "updatedAt",
+        "usage_daily": "usageDaily",
+        "usage_monthly": "usageMonthly",
+        "usage_weekly": "usageWeekly",
     });
 });
 export function createKeysDataFromJSON(jsonString) {

package/esm/models/operations/creatererank.d.ts

@@ -0,0 +1,175 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import * as models from "../index.js";
+export type CreateRerankGlobals = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
+};
+/**
+ * Rerank request input
+ */
+export type CreateRerankRequestBody = {
+    /**
+     * The list of documents to rerank
+     */
+    documents: Array<string>;
+    /**
+     * The rerank model to use
+     */
+    model: string;
+    provider?: models.ProviderPreferences | null | undefined;
+    /**
+     * The search query to rerank documents against
+     */
+    query: string;
+    /**
+     * Number of most relevant documents to return
+     */
+    topN?: number | undefined;
+};
+export type CreateRerankRequest = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
+    requestBody: CreateRerankRequestBody;
+};
+/**
+ * The document object containing the original text
+ */
+export type Document = {
+    /**
+     * The document text
+     */
+    text: string;
+};
+/**
+ * A single rerank result
+ */
+export type Result = {
+    /**
+     * The document object containing the original text
+     */
+    document: Document;
+    /**
+     * Index of the document in the original input list
+     */
+    index: number;
+    /**
+     * Relevance score of the document to the query
+     */
+    relevanceScore: number;
+};
+/**
+ * Usage statistics
+ */
+export type CreateRerankUsage = {
+    /**
+     * Cost of the request in credits
+     */
+    cost?: number | undefined;
+    /**
+     * Number of search units consumed (Cohere billing)
+     */
+    searchUnits?: number | undefined;
+    /**
+     * Total number of tokens used
+     */
+    totalTokens?: number | undefined;
+};
+/**
+ * Rerank response containing ranked results
+ */
+export type CreateRerankResponseBody = {
+    /**
+     * Unique identifier for the rerank response (ORID format)
+     */
+    id?: string | undefined;
+    /**
+     * The model used for reranking
+     */
+    model: string;
+    /**
+     * The provider that served the rerank request
+     */
+    provider?: string | undefined;
+    /**
+     * List of rerank results sorted by relevance
+     */
+    results: Array<Result>;
+    /**
+     * Usage statistics
+     */
+    usage?: CreateRerankUsage | undefined;
+};
+export type CreateRerankResponse = CreateRerankResponseBody | string;
+/** @internal */
+export type CreateRerankRequestBody$Outbound = {
+    documents: Array<string>;
+    model: string;
+    provider?: models.ProviderPreferences$Outbound | null | undefined;
+    query: string;
+    top_n?: number | undefined;
+};
+/** @internal */
+export declare const CreateRerankRequestBody$outboundSchema: z.ZodType<CreateRerankRequestBody$Outbound, CreateRerankRequestBody>;
+export declare function createRerankRequestBodyToJSON(createRerankRequestBody: CreateRerankRequestBody): string;
+/** @internal */
+export type CreateRerankRequest$Outbound = {
+    "HTTP-Referer"?: string | undefined;
+    appTitle?: string | undefined;
+    appCategories?: string | undefined;
+    RequestBody: CreateRerankRequestBody$Outbound;
+};
+/** @internal */
+export declare const CreateRerankRequest$outboundSchema: z.ZodType<CreateRerankRequest$Outbound, CreateRerankRequest>;
+export declare function createRerankRequestToJSON(createRerankRequest: CreateRerankRequest): string;
+/** @internal */
+export declare const Document$inboundSchema: z.ZodType<Document, unknown>;
+export declare function documentFromJSON(jsonString: string): SafeParseResult<Document, SDKValidationError>;
+/** @internal */
+export declare const Result$inboundSchema: z.ZodType<Result, unknown>;
+export declare function resultFromJSON(jsonString: string): SafeParseResult<Result, SDKValidationError>;
+/** @internal */
+export declare const CreateRerankUsage$inboundSchema: z.ZodType<CreateRerankUsage, unknown>;
+export declare function createRerankUsageFromJSON(jsonString: string): SafeParseResult<CreateRerankUsage, SDKValidationError>;
+/** @internal */
+export declare const CreateRerankResponseBody$inboundSchema: z.ZodType<CreateRerankResponseBody, unknown>;
+export declare function createRerankResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateRerankResponseBody, SDKValidationError>;
+/** @internal */
+export declare const CreateRerankResponse$inboundSchema: z.ZodType<CreateRerankResponse, unknown>;
+export declare function createRerankResponseFromJSON(jsonString: string): SafeParseResult<CreateRerankResponse, SDKValidationError>;
+//# sourceMappingURL=creatererank.d.ts.map

package/esm/models/operations/creatererank.js

@@ -0,0 +1,89 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e1de55b94363
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import * as models from "../index.js";
+/** @internal */
+export const CreateRerankRequestBody$outboundSchema = z.object({
+    documents: z.array(z.string()),
+    model: z.string(),
+    provider: z.nullable(models.ProviderPreferences$outboundSchema).optional(),
+    query: z.string(),
+    topN: z.int().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        topN: "top_n",
+    });
+});
+export function createRerankRequestBodyToJSON(createRerankRequestBody) {
+    return JSON.stringify(CreateRerankRequestBody$outboundSchema.parse(createRerankRequestBody));
+}
+/** @internal */
+export const CreateRerankRequest$outboundSchema = z.object({
+    httpReferer: z.string().optional(),
+    appTitle: z.string().optional(),
+    appCategories: z.string().optional(),
+    requestBody: z.lazy(() => CreateRerankRequestBody$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        httpReferer: "HTTP-Referer",
+        requestBody: "RequestBody",
+    });
+});
+export function createRerankRequestToJSON(createRerankRequest) {
+    return JSON.stringify(CreateRerankRequest$outboundSchema.parse(createRerankRequest));
+}
+/** @internal */
+export const Document$inboundSchema = z.object({
+    text: z.string(),
+});
+export function documentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Document$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Document' from JSON`);
+}
+/** @internal */
+export const Result$inboundSchema = z.object({
+    document: z.lazy(() => Document$inboundSchema),
+    index: z.int(),
+    relevance_score: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "relevance_score": "relevanceScore",
+    });
+});
+export function resultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Result$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Result' from JSON`);
+}
+/** @internal */
+export const CreateRerankUsage$inboundSchema = z.object({
+    cost: z.number().optional(),
+    search_units: z.int().optional(),
+    total_tokens: z.int().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "search_units": "searchUnits",
+        "total_tokens": "totalTokens",
+    });
+});
+export function createRerankUsageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateRerankUsage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateRerankUsage' from JSON`);
+}
+/** @internal */
+export const CreateRerankResponseBody$inboundSchema = z.object({
+    id: z.string().optional(),
+    model: z.string(),
+    provider: z.string().optional(),
+    results: z.array(z.lazy(() => Result$inboundSchema)),
+    usage: z.lazy(() => CreateRerankUsage$inboundSchema).optional(),
+});
+export function createRerankResponseBodyFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateRerankResponseBody$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateRerankResponseBody' from JSON`);
+}
+/** @internal */
+export const CreateRerankResponse$inboundSchema = z.union([z.lazy(() => CreateRerankResponseBody$inboundSchema), z.string()]);
+export function createRerankResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateRerankResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateRerankResponse' from JSON`);
+}
+//# sourceMappingURL=creatererank.js.map