/**
 * Cloudflare MAGIC-NETWORK-MONITORING API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service magic-network-monitoring
 */
import * as Schema from "effect/Schema";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import {} from "../errors.js";
export const GetConfigRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/mnm/config" }));
export const GetConfigResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    defaultSampling: Schema.Number,
    name: Schema.String,
    routerIps: Schema.Array(Schema.String),
    warpDevices: Schema.Array(Schema.Struct({
        id: Schema.String,
        name: Schema.String,
        routerIp: Schema.String,
    }).pipe(Schema.encodeKeys({ id: "id", name: "name", routerIp: "router_ip" }))),
})
    .pipe(Schema.encodeKeys({
    defaultSampling: "default_sampling",
    name: "name",
    routerIps: "router_ips",
    warpDevices: "warp_devices",
}))
    .pipe(T.ResponsePath("result"));
export const getConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetConfigRequest,
    output: GetConfigResponse,
    errors: [],
}));
export const CreateConfigRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    defaultSampling: Schema.Number,
    name: Schema.String,
    routerIps: Schema.optional(Schema.Array(Schema.String)),
    warpDevices: Schema.optional(Schema.Array(Schema.Struct({
        id: Schema.String,
        name: Schema.String,
        routerIp: Schema.String,
    }).pipe(Schema.encodeKeys({ id: "id", name: "name", routerIp: "router_ip" })))),
}).pipe(Schema.encodeKeys({
    defaultSampling: "default_sampling",
    name: "name",
    routerIps: "router_ips",
    warpDevices: "warp_devices",
}), T.Http({ method: "POST", path: "/accounts/{account_id}/mnm/config" }));
export const CreateConfigResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    defaultSampling: Schema.Number,
    name: Schema.String,
    routerIps: Schema.Array(Schema.String),
    warpDevices: Schema.Array(Schema.Struct({
        id: Schema.String,
        name: Schema.String,
        routerIp: Schema.String,
    }).pipe(Schema.encodeKeys({ id: "id", name: "name", routerIp: "router_ip" }))),
})
    .pipe(Schema.encodeKeys({
    defaultSampling: "default_sampling",
    name: "name",
    routerIps: "router_ips",
    warpDevices: "warp_devices",
}))
    .pipe(T.ResponsePath("result"));
export const createConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateConfigRequest,
    output: CreateConfigResponse,
    errors: [],
}));
export const UpdateConfigRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    defaultSampling: Schema.Number,
    name: Schema.String,
    routerIps: Schema.optional(Schema.Array(Schema.String)),
    warpDevices: Schema.optional(Schema.Array(Schema.Struct({
        id: Schema.String,
        name: Schema.String,
        routerIp: Schema.String,
    }).pipe(Schema.encodeKeys({ id: "id", name: "name", routerIp: "router_ip" })))),
}).pipe(Schema.encodeKeys({
    defaultSampling: "default_sampling",
    name: "name",
    routerIps: "router_ips",
    warpDevices: "warp_devices",
}), T.Http({ method: "PUT", path: "/accounts/{account_id}/mnm/config" }));
export const UpdateConfigResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    defaultSampling: Schema.Number,
    name: Schema.String,
    routerIps: Schema.Array(Schema.String),
    warpDevices: Schema.Array(Schema.Struct({
        id: Schema.String,
        name: Schema.String,
        routerIp: Schema.String,
    }).pipe(Schema.encodeKeys({ id: "id", name: "name", routerIp: "router_ip" }))),
})
    .pipe(Schema.encodeKeys({
    defaultSampling: "default_sampling",
    name: "name",
    routerIps: "router_ips",
    warpDevices: "warp_devices",
}))
    .pipe(T.ResponsePath("result"));
export const updateConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateConfigRequest,
    output: UpdateConfigResponse,
    errors: [],
}));
export const PatchConfigRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    defaultSampling: Schema.optional(Schema.Number),
    name: Schema.optional(Schema.String),
    routerIps: Schema.optional(Schema.Array(Schema.String)),
    warpDevices: Schema.optional(Schema.Array(Schema.Struct({
        id: Schema.String,
        name: Schema.String,
        routerIp: Schema.String,
    }).pipe(Schema.encodeKeys({ id: "id", name: "name", routerIp: "router_ip" })))),
}).pipe(Schema.encodeKeys({
    defaultSampling: "default_sampling",
    name: "name",
    routerIps: "router_ips",
    warpDevices: "warp_devices",
}), T.Http({ method: "PATCH", path: "/accounts/{account_id}/mnm/config" }));
export const PatchConfigResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    defaultSampling: Schema.Number,
    name: Schema.String,
    routerIps: Schema.Array(Schema.String),
    warpDevices: Schema.Array(Schema.Struct({
        id: Schema.String,
        name: Schema.String,
        routerIp: Schema.String,
    }).pipe(Schema.encodeKeys({ id: "id", name: "name", routerIp: "router_ip" }))),
})
    .pipe(Schema.encodeKeys({
    defaultSampling: "default_sampling",
    name: "name",
    routerIps: "router_ips",
    warpDevices: "warp_devices",
}))
    .pipe(T.ResponsePath("result"));
export const patchConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PatchConfigRequest,
    output: PatchConfigResponse,
    errors: [],
}));
export const DeleteConfigRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({ method: "DELETE", path: "/accounts/{account_id}/mnm/config" }));
export const DeleteConfigResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    defaultSampling: Schema.Number,
    name: Schema.String,
    routerIps: Schema.Array(Schema.String),
    warpDevices: Schema.Array(Schema.Struct({
        id: Schema.String,
        name: Schema.String,
        routerIp: Schema.String,
    }).pipe(Schema.encodeKeys({ id: "id", name: "name", routerIp: "router_ip" }))),
})
    .pipe(Schema.encodeKeys({
    defaultSampling: "default_sampling",
    name: "name",
    routerIps: "router_ips",
    warpDevices: "warp_devices",
}))
    .pipe(T.ResponsePath("result"));
export const deleteConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteConfigRequest,
    output: DeleteConfigResponse,
    errors: [],
}));
export const GetConfigFullRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/mnm/config/full" }));
export const GetConfigFullResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    defaultSampling: Schema.Number,
    name: Schema.String,
    routerIps: Schema.Array(Schema.String),
    warpDevices: Schema.Array(Schema.Struct({
        id: Schema.String,
        name: Schema.String,
        routerIp: Schema.String,
    }).pipe(Schema.encodeKeys({ id: "id", name: "name", routerIp: "router_ip" }))),
})
    .pipe(Schema.encodeKeys({
    defaultSampling: "default_sampling",
    name: "name",
    routerIps: "router_ips",
    warpDevices: "warp_devices",
}))
    .pipe(T.ResponsePath("result"));
export const getConfigFull = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetConfigFullRequest,
    output: GetConfigFullResponse,
    errors: [],
}));
export const GetRuleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    ruleId: Schema.String.pipe(T.HttpPath("ruleId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/mnm/rules/{ruleId}" }));
export const GetRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    automaticAdvertisement: Schema.Union([Schema.Boolean, Schema.Null]),
    name: Schema.String,
    prefixes: Schema.Array(Schema.String),
    type: Schema.Literals(["threshold", "zscore", "advanced_ddos"]),
    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    bandwidthThreshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    duration: Schema.optional(Schema.Union([
        Schema.Literals(["1m", "5m", "10m", "15m", "20m", "30m", "45m", "60m"]),
        Schema.Null,
    ])),
    packetThreshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    prefixMatch: Schema.optional(Schema.Union([
        Schema.Literal("exact"),
        Schema.Literal("subnet"),
        Schema.Literal("supernet"),
        Schema.Null,
    ])),
    zscoreSensitivity: Schema.optional(Schema.Union([
        Schema.Literal("low"),
        Schema.Literal("medium"),
        Schema.Literal("high"),
        Schema.Null,
    ])),
    zscoreTarget: Schema.optional(Schema.Union([
        Schema.Literal("bits"),
        Schema.Literal("packets"),
        Schema.Null,
    ])),
})
    .pipe(Schema.encodeKeys({
    automaticAdvertisement: "automatic_advertisement",
    name: "name",
    prefixes: "prefixes",
    type: "type",
    id: "id",
    bandwidthThreshold: "bandwidth_threshold",
    duration: "duration",
    packetThreshold: "packet_threshold",
    prefixMatch: "prefix_match",
    zscoreSensitivity: "zscore_sensitivity",
    zscoreTarget: "zscore_target",
}))
    .pipe(T.ResponsePath("result"));
export const getRule = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetRuleRequest,
    output: GetRuleResponse,
    errors: [],
}));
export const ListRulesRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/mnm/rules" }));
export const ListRulesResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    result: Schema.Array(Schema.Union([
        Schema.Struct({
            automaticAdvertisement: Schema.Union([Schema.Boolean, Schema.Null]),
            name: Schema.String,
            prefixes: Schema.Array(Schema.String),
            type: Schema.Literals(["threshold", "zscore", "advanced_ddos"]),
            id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            bandwidthThreshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
            duration: Schema.optional(Schema.Union([
                Schema.Literals([
                    "1m",
                    "5m",
                    "10m",
                    "15m",
                    "20m",
                    "30m",
                    "45m",
                    "60m",
                ]),
                Schema.Null,
            ])),
            packetThreshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
            prefixMatch: Schema.optional(Schema.Union([
                Schema.Literal("exact"),
                Schema.Literal("subnet"),
                Schema.Literal("supernet"),
                Schema.Null,
            ])),
            zscoreSensitivity: Schema.optional(Schema.Union([
                Schema.Literal("low"),
                Schema.Literal("medium"),
                Schema.Literal("high"),
                Schema.Null,
            ])),
            zscoreTarget: Schema.optional(Schema.Union([
                Schema.Literal("bits"),
                Schema.Literal("packets"),
                Schema.Null,
            ])),
        }).pipe(Schema.encodeKeys({
            automaticAdvertisement: "automatic_advertisement",
            name: "name",
            prefixes: "prefixes",
            type: "type",
            id: "id",
            bandwidthThreshold: "bandwidth_threshold",
            duration: "duration",
            packetThreshold: "packet_threshold",
            prefixMatch: "prefix_match",
            zscoreSensitivity: "zscore_sensitivity",
            zscoreTarget: "zscore_target",
        })),
        Schema.Null,
    ])),
});
export const listRules = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListRulesRequest,
    output: ListRulesResponse,
    errors: [],
    pagination: {
        mode: "single",
        items: "result",
    },
}));
export const CreateRuleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    duration: Schema.Literals([
        "1m",
        "5m",
        "10m",
        "15m",
        "20m",
        "30m",
        "45m",
        "60m",
    ]),
    name: Schema.String,
    automaticAdvertisement: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
    bandwidth: Schema.optional(Schema.Number),
    packetThreshold: Schema.optional(Schema.Number),
    prefixes: Schema.optional(Schema.Array(Schema.String)),
}).pipe(Schema.encodeKeys({
    duration: "duration",
    name: "name",
    automaticAdvertisement: "automatic_advertisement",
    bandwidth: "bandwidth",
    packetThreshold: "packet_threshold",
    prefixes: "prefixes",
}), T.Http({ method: "POST", path: "/accounts/{account_id}/mnm/rules" }));
export const CreateRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    automaticAdvertisement: Schema.Union([Schema.Boolean, Schema.Null]),
    name: Schema.String,
    prefixes: Schema.Array(Schema.String),
    type: Schema.Literals(["threshold", "zscore", "advanced_ddos"]),
    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    bandwidthThreshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    duration: Schema.optional(Schema.Union([
        Schema.Literals(["1m", "5m", "10m", "15m", "20m", "30m", "45m", "60m"]),
        Schema.Null,
    ])),
    packetThreshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    prefixMatch: Schema.optional(Schema.Union([
        Schema.Literal("exact"),
        Schema.Literal("subnet"),
        Schema.Literal("supernet"),
        Schema.Null,
    ])),
    zscoreSensitivity: Schema.optional(Schema.Union([
        Schema.Literal("low"),
        Schema.Literal("medium"),
        Schema.Literal("high"),
        Schema.Null,
    ])),
    zscoreTarget: Schema.optional(Schema.Union([
        Schema.Literal("bits"),
        Schema.Literal("packets"),
        Schema.Null,
    ])),
})
    .pipe(Schema.encodeKeys({
    automaticAdvertisement: "automatic_advertisement",
    name: "name",
    prefixes: "prefixes",
    type: "type",
    id: "id",
    bandwidthThreshold: "bandwidth_threshold",
    duration: "duration",
    packetThreshold: "packet_threshold",
    prefixMatch: "prefix_match",
    zscoreSensitivity: "zscore_sensitivity",
    zscoreTarget: "zscore_target",
}))
    .pipe(T.ResponsePath("result"));
export const createRule = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateRuleRequest,
    output: CreateRuleResponse,
    errors: [],
}));
export const UpdateRuleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    duration: Schema.Literals([
        "1m",
        "5m",
        "10m",
        "15m",
        "20m",
        "30m",
        "45m",
        "60m",
    ]),
    name: Schema.String,
    id: Schema.optional(Schema.String),
    automaticAdvertisement: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
    bandwidth: Schema.optional(Schema.Number),
    packetThreshold: Schema.optional(Schema.Number),
    prefixes: Schema.optional(Schema.Array(Schema.String)),
}).pipe(Schema.encodeKeys({
    duration: "duration",
    name: "name",
    id: "id",
    automaticAdvertisement: "automatic_advertisement",
    bandwidth: "bandwidth",
    packetThreshold: "packet_threshold",
    prefixes: "prefixes",
}), T.Http({ method: "PUT", path: "/accounts/{account_id}/mnm/rules" }));
export const UpdateRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    automaticAdvertisement: Schema.Union([Schema.Boolean, Schema.Null]),
    name: Schema.String,
    prefixes: Schema.Array(Schema.String),
    type: Schema.Literals(["threshold", "zscore", "advanced_ddos"]),
    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    bandwidthThreshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    duration: Schema.optional(Schema.Union([
        Schema.Literals(["1m", "5m", "10m", "15m", "20m", "30m", "45m", "60m"]),
        Schema.Null,
    ])),
    packetThreshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    prefixMatch: Schema.optional(Schema.Union([
        Schema.Literal("exact"),
        Schema.Literal("subnet"),
        Schema.Literal("supernet"),
        Schema.Null,
    ])),
    zscoreSensitivity: Schema.optional(Schema.Union([
        Schema.Literal("low"),
        Schema.Literal("medium"),
        Schema.Literal("high"),
        Schema.Null,
    ])),
    zscoreTarget: Schema.optional(Schema.Union([
        Schema.Literal("bits"),
        Schema.Literal("packets"),
        Schema.Null,
    ])),
})
    .pipe(Schema.encodeKeys({
    automaticAdvertisement: "automatic_advertisement",
    name: "name",
    prefixes: "prefixes",
    type: "type",
    id: "id",
    bandwidthThreshold: "bandwidth_threshold",
    duration: "duration",
    packetThreshold: "packet_threshold",
    prefixMatch: "prefix_match",
    zscoreSensitivity: "zscore_sensitivity",
    zscoreTarget: "zscore_target",
}))
    .pipe(T.ResponsePath("result"));
export const updateRule = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateRuleRequest,
    output: UpdateRuleResponse,
    errors: [],
}));
export const PatchRuleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    ruleId: Schema.String.pipe(T.HttpPath("ruleId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    automaticAdvertisement: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
    bandwidth: Schema.optional(Schema.Number),
    duration: Schema.optional(Schema.Literals(["1m", "5m", "10m", "15m", "20m", "30m", "45m", "60m"])),
    name: Schema.optional(Schema.String),
    packetThreshold: Schema.optional(Schema.Number),
    prefixes: Schema.optional(Schema.Array(Schema.String)),
}).pipe(Schema.encodeKeys({
    automaticAdvertisement: "automatic_advertisement",
    bandwidth: "bandwidth",
    duration: "duration",
    name: "name",
    packetThreshold: "packet_threshold",
    prefixes: "prefixes",
}), T.Http({
    method: "PATCH",
    path: "/accounts/{account_id}/mnm/rules/{ruleId}",
}));
export const PatchRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    automaticAdvertisement: Schema.Union([Schema.Boolean, Schema.Null]),
    name: Schema.String,
    prefixes: Schema.Array(Schema.String),
    type: Schema.Literals(["threshold", "zscore", "advanced_ddos"]),
    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    bandwidthThreshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    duration: Schema.optional(Schema.Union([
        Schema.Literals(["1m", "5m", "10m", "15m", "20m", "30m", "45m", "60m"]),
        Schema.Null,
    ])),
    packetThreshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    prefixMatch: Schema.optional(Schema.Union([
        Schema.Literal("exact"),
        Schema.Literal("subnet"),
        Schema.Literal("supernet"),
        Schema.Null,
    ])),
    zscoreSensitivity: Schema.optional(Schema.Union([
        Schema.Literal("low"),
        Schema.Literal("medium"),
        Schema.Literal("high"),
        Schema.Null,
    ])),
    zscoreTarget: Schema.optional(Schema.Union([
        Schema.Literal("bits"),
        Schema.Literal("packets"),
        Schema.Null,
    ])),
})
    .pipe(Schema.encodeKeys({
    automaticAdvertisement: "automatic_advertisement",
    name: "name",
    prefixes: "prefixes",
    type: "type",
    id: "id",
    bandwidthThreshold: "bandwidth_threshold",
    duration: "duration",
    packetThreshold: "packet_threshold",
    prefixMatch: "prefix_match",
    zscoreSensitivity: "zscore_sensitivity",
    zscoreTarget: "zscore_target",
}))
    .pipe(T.ResponsePath("result"));
export const patchRule = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PatchRuleRequest,
    output: PatchRuleResponse,
    errors: [],
}));
export const DeleteRuleRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    ruleId: Schema.String.pipe(T.HttpPath("ruleId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "DELETE",
    path: "/accounts/{account_id}/mnm/rules/{ruleId}",
}));
export const DeleteRuleResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    automaticAdvertisement: Schema.Union([Schema.Boolean, Schema.Null]),
    name: Schema.String,
    prefixes: Schema.Array(Schema.String),
    type: Schema.Literals(["threshold", "zscore", "advanced_ddos"]),
    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    bandwidthThreshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    duration: Schema.optional(Schema.Union([
        Schema.Literals(["1m", "5m", "10m", "15m", "20m", "30m", "45m", "60m"]),
        Schema.Null,
    ])),
    packetThreshold: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    prefixMatch: Schema.optional(Schema.Union([
        Schema.Literal("exact"),
        Schema.Literal("subnet"),
        Schema.Literal("supernet"),
        Schema.Null,
    ])),
    zscoreSensitivity: Schema.optional(Schema.Union([
        Schema.Literal("low"),
        Schema.Literal("medium"),
        Schema.Literal("high"),
        Schema.Null,
    ])),
    zscoreTarget: Schema.optional(Schema.Union([
        Schema.Literal("bits"),
        Schema.Literal("packets"),
        Schema.Null,
    ])),
})
    .pipe(Schema.encodeKeys({
    automaticAdvertisement: "automatic_advertisement",
    name: "name",
    prefixes: "prefixes",
    type: "type",
    id: "id",
    bandwidthThreshold: "bandwidth_threshold",
    duration: "duration",
    packetThreshold: "packet_threshold",
    prefixMatch: "prefix_match",
    zscoreSensitivity: "zscore_sensitivity",
    zscoreTarget: "zscore_target",
}))
    .pipe(T.ResponsePath("result"));
export const deleteRule = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteRuleRequest,
    output: DeleteRuleResponse,
    errors: [],
}));
export const PatchRuleAdvertisementRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    ruleId: Schema.String.pipe(T.HttpPath("ruleId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    body: Schema.Unknown.pipe(T.HttpBody()),
}).pipe(T.Http({
    method: "PATCH",
    path: "/accounts/{account_id}/mnm/rules/{ruleId}/advertisement",
}));
export const PatchRuleAdvertisementResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    automaticAdvertisement: Schema.Union([Schema.Boolean, Schema.Null]),
})
    .pipe(Schema.encodeKeys({ automaticAdvertisement: "automatic_advertisement" }))
    .pipe(T.ResponsePath("result"));
export const patchRuleAdvertisement = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PatchRuleAdvertisementRequest,
    output: PatchRuleAdvertisementResponse,
    errors: [],
}));
export const CreateVpcFlowTokenRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "POST",
    path: "/accounts/{account_id}/mnm/vpc-flows/token",
}));
export const CreateVpcFlowTokenResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(T.ResponsePath("result"));
export const createVpcFlowToken = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateVpcFlowTokenRequest,
    output: CreateVpcFlowTokenResponse,
    errors: [],
}));
//# sourceMappingURL=magic-network-monitoring.js.map