/**
 * Cloudflare CLOUDFORCE-ONE API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service cloudforce-one
 */
import * as Schema from "effect/Schema";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import {} from "../errors.js";
import { UploadableSchema } from "../schemas.js";
export const GetBinaryStorageRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    hash: Schema.String.pipe(T.HttpPath("hash")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/binary/{hash}",
}));
export const GetBinaryStorageResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
export const getBinaryStorage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetBinaryStorageRequest,
    output: GetBinaryStorageResponse,
    errors: [],
}));
export const CreateBinaryStorageRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    file: UploadableSchema.pipe(T.HttpFormDataFile()),
}).pipe(T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/binary",
    contentType: "multipart",
}));
export const CreateBinaryStorageResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    contentType: Schema.String,
    md5: Schema.String,
    sha1: Schema.String,
    sha256: Schema.String,
}).pipe(Schema.encodeKeys({
    contentType: "content_type",
    md5: "md5",
    sha1: "sha1",
    sha256: "sha256",
}));
export const createBinaryStorage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateBinaryStorageRequest,
    output: CreateBinaryStorageResponse,
    errors: [],
}));
export const GetRequestRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    requestId: Schema.String.pipe(T.HttpPath("requestId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/requests/{requestId}",
}));
export const GetRequestResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    content: Schema.String,
    created: Schema.String,
    priority: Schema.String,
    request: Schema.String,
    summary: Schema.String,
    tlp: Schema.Literals(["clear", "amber", "amber-strict", "green", "red"]),
    updated: Schema.String,
    completed: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    messageTokens: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    readableId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    status: Schema.optional(Schema.Union([
        Schema.Literals([
            "open",
            "accepted",
            "reported",
            "approved",
            "completed",
            "declined",
        ]),
        Schema.Null,
    ])),
    tokens: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
})
    .pipe(Schema.encodeKeys({
    id: "id",
    content: "content",
    created: "created",
    priority: "priority",
    request: "request",
    summary: "summary",
    tlp: "tlp",
    updated: "updated",
    completed: "completed",
    messageTokens: "message_tokens",
    readableId: "readable_id",
    status: "status",
    tokens: "tokens",
}))
    .pipe(T.ResponsePath("result"));
export const getRequest = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetRequestRequest,
    output: GetRequestResponse,
    errors: [],
}));
export const ListRequestsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    page: Schema.Number,
    perPage: Schema.Number,
    completedAfter: Schema.optional(Schema.String),
    completedBefore: Schema.optional(Schema.String),
    createdAfter: Schema.optional(Schema.String),
    createdBefore: Schema.optional(Schema.String),
    requestType: Schema.optional(Schema.String),
    sortBy: Schema.optional(Schema.String),
    sortOrder: Schema.optional(Schema.Literals(["asc", "desc"])),
    status: Schema.optional(Schema.Literals([
        "open",
        "accepted",
        "reported",
        "approved",
        "completed",
        "declined",
    ])),
}).pipe(Schema.encodeKeys({
    page: "page",
    perPage: "per_page",
    completedAfter: "completed_after",
    completedBefore: "completed_before",
    createdAfter: "created_after",
    createdBefore: "created_before",
    requestType: "request_type",
    sortBy: "sort_by",
    sortOrder: "sort_order",
    status: "status",
}), T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/requests",
}));
export const ListRequestsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    result: Schema.Array(Schema.Struct({
        id: Schema.String,
        created: Schema.String,
        priority: Schema.Literals(["routine", "high", "urgent"]),
        request: Schema.String,
        summary: Schema.String,
        tlp: Schema.Literals(["clear", "amber", "amber-strict", "green", "red"]),
        updated: Schema.String,
        completed: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        messageTokens: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
        readableId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        status: Schema.optional(Schema.Union([
            Schema.Literals([
                "open",
                "accepted",
                "reported",
                "approved",
                "completed",
                "declined",
            ]),
            Schema.Null,
        ])),
        tokens: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    }).pipe(Schema.encodeKeys({
        id: "id",
        created: "created",
        priority: "priority",
        request: "request",
        summary: "summary",
        tlp: "tlp",
        updated: "updated",
        completed: "completed",
        messageTokens: "message_tokens",
        readableId: "readable_id",
        status: "status",
        tokens: "tokens",
    }))),
});
export const listRequests = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListRequestsRequest,
    output: ListRequestsResponse,
    errors: [],
    pagination: {
        mode: "single",
        items: "result",
    },
}));
export const CreateRequestRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    content: Schema.optional(Schema.String),
    priority: Schema.optional(Schema.String),
    requestType: Schema.optional(Schema.String),
    summary: Schema.optional(Schema.String),
    tlp: Schema.optional(Schema.Literals(["clear", "amber", "amber-strict", "green", "red"])),
}).pipe(Schema.encodeKeys({
    content: "content",
    priority: "priority",
    requestType: "request_type",
    summary: "summary",
    tlp: "tlp",
}), T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/requests/new",
}));
export const CreateRequestResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    content: Schema.String,
    created: Schema.String,
    priority: Schema.String,
    request: Schema.String,
    summary: Schema.String,
    tlp: Schema.Literals(["clear", "amber", "amber-strict", "green", "red"]),
    updated: Schema.String,
    completed: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    messageTokens: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    readableId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    status: Schema.optional(Schema.Union([
        Schema.Literals([
            "open",
            "accepted",
            "reported",
            "approved",
            "completed",
            "declined",
        ]),
        Schema.Null,
    ])),
    tokens: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
})
    .pipe(Schema.encodeKeys({
    id: "id",
    content: "content",
    created: "created",
    priority: "priority",
    request: "request",
    summary: "summary",
    tlp: "tlp",
    updated: "updated",
    completed: "completed",
    messageTokens: "message_tokens",
    readableId: "readable_id",
    status: "status",
    tokens: "tokens",
}))
    .pipe(T.ResponsePath("result"));
export const createRequest = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateRequestRequest,
    output: CreateRequestResponse,
    errors: [],
}));
export const UpdateRequestRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    requestId: Schema.String.pipe(T.HttpPath("requestId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    content: Schema.optional(Schema.String),
    priority: Schema.optional(Schema.String),
    requestType: Schema.optional(Schema.String),
    summary: Schema.optional(Schema.String),
    tlp: Schema.optional(Schema.Literals(["clear", "amber", "amber-strict", "green", "red"])),
}).pipe(Schema.encodeKeys({
    content: "content",
    priority: "priority",
    requestType: "request_type",
    summary: "summary",
    tlp: "tlp",
}), T.Http({
    method: "PUT",
    path: "/accounts/{account_id}/cloudforce-one/requests/{requestId}",
}));
export const UpdateRequestResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    content: Schema.String,
    created: Schema.String,
    priority: Schema.String,
    request: Schema.String,
    summary: Schema.String,
    tlp: Schema.Literals(["clear", "amber", "amber-strict", "green", "red"]),
    updated: Schema.String,
    completed: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    messageTokens: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    readableId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    status: Schema.optional(Schema.Union([
        Schema.Literals([
            "open",
            "accepted",
            "reported",
            "approved",
            "completed",
            "declined",
        ]),
        Schema.Null,
    ])),
    tokens: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
})
    .pipe(Schema.encodeKeys({
    id: "id",
    content: "content",
    created: "created",
    priority: "priority",
    request: "request",
    summary: "summary",
    tlp: "tlp",
    updated: "updated",
    completed: "completed",
    messageTokens: "message_tokens",
    readableId: "readable_id",
    status: "status",
    tokens: "tokens",
}))
    .pipe(T.ResponsePath("result"));
export const updateRequest = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateRequestRequest,
    output: UpdateRequestResponse,
    errors: [],
}));
export const DeleteRequestRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    requestId: Schema.String.pipe(T.HttpPath("requestId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "DELETE",
    path: "/accounts/{account_id}/cloudforce-one/requests/{requestId}",
}));
export const DeleteRequestResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    errors: Schema.Array(Schema.Struct({
        code: Schema.Number,
        message: Schema.String,
        documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        source: Schema.optional(Schema.Union([
            Schema.Struct({
                pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            }),
            Schema.Null,
        ])),
    }).pipe(Schema.encodeKeys({
        code: "code",
        message: "message",
        documentationUrl: "documentation_url",
        source: "source",
    }))),
    messages: Schema.Array(Schema.Struct({
        code: Schema.Number,
        message: Schema.String,
        documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        source: Schema.optional(Schema.Union([
            Schema.Struct({
                pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            }),
            Schema.Null,
        ])),
    }).pipe(Schema.encodeKeys({
        code: "code",
        message: "message",
        documentationUrl: "documentation_url",
        source: "source",
    }))),
    success: Schema.Literal(true),
});
export const deleteRequest = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteRequestRequest,
    output: DeleteRequestResponse,
    errors: [],
}));
export const ConstantsRequestRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/requests/constants",
}));
export const ConstantsRequestResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    priority: Schema.optional(Schema.Union([
        Schema.Array(Schema.Literals(["routine", "high", "urgent"])),
        Schema.Null,
    ])),
    status: Schema.optional(Schema.Union([
        Schema.Array(Schema.Literals([
            "open",
            "accepted",
            "reported",
            "approved",
            "completed",
            "declined",
        ])),
        Schema.Null,
    ])),
    tlp: Schema.optional(Schema.Union([
        Schema.Array(Schema.Literals(["clear", "amber", "amber-strict", "green", "red"])),
        Schema.Null,
    ])),
}).pipe(T.ResponsePath("result"));
export const constantsRequest = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ConstantsRequestRequest,
    output: ConstantsRequestResponse,
    errors: [],
}));
export const QuotaRequestRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/requests/quota",
}));
export const QuotaRequestResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    anniversaryDate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    quarterAnniversaryDate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    quota: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    remaining: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
})
    .pipe(Schema.encodeKeys({
    anniversaryDate: "anniversary_date",
    quarterAnniversaryDate: "quarter_anniversary_date",
    quota: "quota",
    remaining: "remaining",
}))
    .pipe(T.ResponsePath("result"));
export const quotaRequest = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: QuotaRequestRequest,
    output: QuotaRequestResponse,
    errors: [],
}));
export const TypesRequestRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/requests/types",
}));
export const TypesRequestResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    result: Schema.Array(Schema.String),
});
export const typesRequest = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: TypesRequestRequest,
    output: TypesRequestResponse,
    errors: [],
    pagination: {
        mode: "single",
        items: "result",
    },
}));
export const GetRequestAssetRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    requestId: Schema.String.pipe(T.HttpPath("requestId")),
    assetId: Schema.String.pipe(T.HttpPath("assetId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/requests/{requestId}/asset/{assetId}",
}));
export const GetRequestAssetResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    result: Schema.Array(Schema.Struct({
        id: Schema.Number,
        name: Schema.String,
        created: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        fileType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    }).pipe(Schema.encodeKeys({
        id: "id",
        name: "name",
        created: "created",
        description: "description",
        fileType: "file_type",
    }))),
});
export const getRequestAsset = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: GetRequestAssetRequest,
    output: GetRequestAssetResponse,
    errors: [],
    pagination: {
        mode: "single",
        items: "result",
    },
}));
export const CreateRequestAssetRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    requestId: Schema.String.pipe(T.HttpPath("requestId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    page: Schema.Number,
    perPage: Schema.Number,
}).pipe(Schema.encodeKeys({ page: "page", perPage: "per_page" }), T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/requests/{requestId}/asset",
}));
export const CreateRequestAssetResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    result: Schema.Array(Schema.Struct({
        id: Schema.Number,
        name: Schema.String,
        created: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        fileType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    }).pipe(Schema.encodeKeys({
        id: "id",
        name: "name",
        created: "created",
        description: "description",
        fileType: "file_type",
    }))),
});
export const createRequestAsset = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: CreateRequestAssetRequest,
    output: CreateRequestAssetResponse,
    errors: [],
    pagination: {
        mode: "single",
        items: "result",
    },
}));
export const UpdateRequestAssetRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    requestId: Schema.String.pipe(T.HttpPath("requestId")),
    assetId: Schema.String.pipe(T.HttpPath("assetId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    source: Schema.optional(Schema.String),
}).pipe(T.Http({
    method: "PUT",
    path: "/accounts/{account_id}/cloudforce-one/requests/{requestId}/asset/{assetId}",
}));
export const UpdateRequestAssetResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.Number,
    name: Schema.String,
    created: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    description: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    fileType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
})
    .pipe(Schema.encodeKeys({
    id: "id",
    name: "name",
    created: "created",
    description: "description",
    fileType: "file_type",
}))
    .pipe(T.ResponsePath("result"));
export const updateRequestAsset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateRequestAssetRequest,
    output: UpdateRequestAssetResponse,
    errors: [],
}));
export const DeleteRequestAssetRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    requestId: Schema.String.pipe(T.HttpPath("requestId")),
    assetId: Schema.String.pipe(T.HttpPath("assetId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "DELETE",
    path: "/accounts/{account_id}/cloudforce-one/requests/{requestId}/asset/{assetId}",
}));
export const DeleteRequestAssetResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    errors: Schema.Array(Schema.Struct({
        code: Schema.Number,
        message: Schema.String,
        documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        source: Schema.optional(Schema.Union([
            Schema.Struct({
                pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            }),
            Schema.Null,
        ])),
    }).pipe(Schema.encodeKeys({
        code: "code",
        message: "message",
        documentationUrl: "documentation_url",
        source: "source",
    }))),
    messages: Schema.Array(Schema.Struct({
        code: Schema.Number,
        message: Schema.String,
        documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        source: Schema.optional(Schema.Union([
            Schema.Struct({
                pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            }),
            Schema.Null,
        ])),
    }).pipe(Schema.encodeKeys({
        code: "code",
        message: "message",
        documentationUrl: "documentation_url",
        source: "source",
    }))),
    success: Schema.Literal(true),
});
export const deleteRequestAsset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteRequestAssetRequest,
    output: DeleteRequestAssetResponse,
    errors: [],
}));
export const GetRequestMessageRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    requestId: Schema.String.pipe(T.HttpPath("requestId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    page: Schema.Number,
    perPage: Schema.Number,
    after: Schema.optional(Schema.String),
    before: Schema.optional(Schema.String),
    sortBy: Schema.optional(Schema.String),
    sortOrder: Schema.optional(Schema.Literals(["asc", "desc"])),
}).pipe(Schema.encodeKeys({
    page: "page",
    perPage: "per_page",
    after: "after",
    before: "before",
    sortBy: "sort_by",
    sortOrder: "sort_order",
}), T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/requests/{requestId}/message",
}));
export const GetRequestMessageResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    result: Schema.Array(Schema.Struct({
        code: Schema.Number,
        message: Schema.String,
        documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        source: Schema.optional(Schema.Union([
            Schema.Struct({
                pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            }),
            Schema.Null,
        ])),
    }).pipe(Schema.encodeKeys({
        code: "code",
        message: "message",
        documentationUrl: "documentation_url",
        source: "source",
    }))),
});
export const getRequestMessage = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: GetRequestMessageRequest,
    output: GetRequestMessageResponse,
    errors: [],
    pagination: {
        mode: "single",
        items: "result",
    },
}));
export const CreateRequestMessageRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    requestId: Schema.String.pipe(T.HttpPath("requestId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    content: Schema.optional(Schema.String),
}).pipe(T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/requests/{requestId}/message/new",
}));
export const CreateRequestMessageResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    code: Schema.Number,
    message: Schema.String,
    documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    source: Schema.optional(Schema.Union([
        Schema.Struct({
            pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        }),
        Schema.Null,
    ])),
})
    .pipe(Schema.encodeKeys({
    code: "code",
    message: "message",
    documentationUrl: "documentation_url",
    source: "source",
}))
    .pipe(T.ResponsePath("result"));
export const createRequestMessage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateRequestMessageRequest,
    output: CreateRequestMessageResponse,
    errors: [],
}));
export const UpdateRequestMessageRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    requestId: Schema.String.pipe(T.HttpPath("requestId")),
    messageId: Schema.Number.pipe(T.HttpPath("messageId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    content: Schema.optional(Schema.String),
}).pipe(T.Http({
    method: "PUT",
    path: "/accounts/{account_id}/cloudforce-one/requests/{requestId}/message/{messageId}",
}));
export const UpdateRequestMessageResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    code: Schema.Number,
    message: Schema.String,
    documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    source: Schema.optional(Schema.Union([
        Schema.Struct({
            pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        }),
        Schema.Null,
    ])),
})
    .pipe(Schema.encodeKeys({
    code: "code",
    message: "message",
    documentationUrl: "documentation_url",
    source: "source",
}))
    .pipe(T.ResponsePath("result"));
export const updateRequestMessage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateRequestMessageRequest,
    output: UpdateRequestMessageResponse,
    errors: [],
}));
export const DeleteRequestMessageRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    requestId: Schema.String.pipe(T.HttpPath("requestId")),
    messageId: Schema.Number.pipe(T.HttpPath("messageId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "DELETE",
    path: "/accounts/{account_id}/cloudforce-one/requests/{requestId}/message/{messageId}",
}));
export const DeleteRequestMessageResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    errors: Schema.Array(Schema.Struct({
        code: Schema.Number,
        message: Schema.String,
        documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        source: Schema.optional(Schema.Union([
            Schema.Struct({
                pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            }),
            Schema.Null,
        ])),
    }).pipe(Schema.encodeKeys({
        code: "code",
        message: "message",
        documentationUrl: "documentation_url",
        source: "source",
    }))),
    messages: Schema.Array(Schema.Struct({
        code: Schema.Number,
        message: Schema.String,
        documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        source: Schema.optional(Schema.Union([
            Schema.Struct({
                pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            }),
            Schema.Null,
        ])),
    }).pipe(Schema.encodeKeys({
        code: "code",
        message: "message",
        documentationUrl: "documentation_url",
        source: "source",
    }))),
    success: Schema.Literal(true),
});
export const deleteRequestMessage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteRequestMessageRequest,
    output: DeleteRequestMessageResponse,
    errors: [],
}));
export const GetRequestPriorityRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    priorityId: Schema.String.pipe(T.HttpPath("priorityId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/requests/priority/{priorityId}",
}));
export const GetRequestPriorityResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    content: Schema.String,
    created: Schema.String,
    priority: Schema.String,
    request: Schema.String,
    summary: Schema.String,
    tlp: Schema.Literals(["clear", "amber", "amber-strict", "green", "red"]),
    updated: Schema.String,
    completed: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    messageTokens: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    readableId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    status: Schema.optional(Schema.Union([
        Schema.Literals([
            "open",
            "accepted",
            "reported",
            "approved",
            "completed",
            "declined",
        ]),
        Schema.Null,
    ])),
    tokens: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
})
    .pipe(Schema.encodeKeys({
    id: "id",
    content: "content",
    created: "created",
    priority: "priority",
    request: "request",
    summary: "summary",
    tlp: "tlp",
    updated: "updated",
    completed: "completed",
    messageTokens: "message_tokens",
    readableId: "readable_id",
    status: "status",
    tokens: "tokens",
}))
    .pipe(T.ResponsePath("result"));
export const getRequestPriority = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetRequestPriorityRequest,
    output: GetRequestPriorityResponse,
    errors: [],
}));
export const CreateRequestPriorityRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    labels: Schema.Array(Schema.String),
    priority: Schema.Number,
    requirement: Schema.String,
    tlp: Schema.Literals(["clear", "amber", "amber-strict", "green", "red"]),
}).pipe(T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/requests/priority/new",
}));
export const CreateRequestPriorityResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    created: Schema.String,
    labels: Schema.Array(Schema.String),
    priority: Schema.Number,
    requirement: Schema.String,
    tlp: Schema.Literals(["clear", "amber", "amber-strict", "green", "red"]),
    updated: Schema.String,
}).pipe(T.ResponsePath("result"));
export const createRequestPriority = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateRequestPriorityRequest,
    output: CreateRequestPriorityResponse,
    errors: [],
}));
export const UpdateRequestPriorityRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    priorityId: Schema.String.pipe(T.HttpPath("priorityId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    labels: Schema.Array(Schema.String),
    priority: Schema.Number,
    requirement: Schema.String,
    tlp: Schema.Literals(["clear", "amber", "amber-strict", "green", "red"]),
}).pipe(T.Http({
    method: "PUT",
    path: "/accounts/{account_id}/cloudforce-one/requests/priority/{priorityId}",
}));
export const UpdateRequestPriorityResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    content: Schema.String,
    created: Schema.String,
    priority: Schema.String,
    request: Schema.String,
    summary: Schema.String,
    tlp: Schema.Literals(["clear", "amber", "amber-strict", "green", "red"]),
    updated: Schema.String,
    completed: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    messageTokens: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    readableId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    status: Schema.optional(Schema.Union([
        Schema.Literals([
            "open",
            "accepted",
            "reported",
            "approved",
            "completed",
            "declined",
        ]),
        Schema.Null,
    ])),
    tokens: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
})
    .pipe(Schema.encodeKeys({
    id: "id",
    content: "content",
    created: "created",
    priority: "priority",
    request: "request",
    summary: "summary",
    tlp: "tlp",
    updated: "updated",
    completed: "completed",
    messageTokens: "message_tokens",
    readableId: "readable_id",
    status: "status",
    tokens: "tokens",
}))
    .pipe(T.ResponsePath("result"));
export const updateRequestPriority = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateRequestPriorityRequest,
    output: UpdateRequestPriorityResponse,
    errors: [],
}));
export const DeleteRequestPriorityRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    priorityId: Schema.String.pipe(T.HttpPath("priorityId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "DELETE",
    path: "/accounts/{account_id}/cloudforce-one/requests/priority/{priorityId}",
}));
export const DeleteRequestPriorityResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    errors: Schema.Array(Schema.Struct({
        code: Schema.Number,
        message: Schema.String,
        documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        source: Schema.optional(Schema.Union([
            Schema.Struct({
                pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            }),
            Schema.Null,
        ])),
    }).pipe(Schema.encodeKeys({
        code: "code",
        message: "message",
        documentationUrl: "documentation_url",
        source: "source",
    }))),
    messages: Schema.Array(Schema.Struct({
        code: Schema.Number,
        message: Schema.String,
        documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        source: Schema.optional(Schema.Union([
            Schema.Struct({
                pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            }),
            Schema.Null,
        ])),
    }).pipe(Schema.encodeKeys({
        code: "code",
        message: "message",
        documentationUrl: "documentation_url",
        source: "source",
    }))),
    success: Schema.Literal(true),
});
export const deleteRequestPriority = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteRequestPriorityRequest,
    output: DeleteRequestPriorityResponse,
    errors: [],
}));
export const QuotaRequestPriorityRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/requests/priority/quota",
}));
export const QuotaRequestPriorityResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    anniversaryDate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    quarterAnniversaryDate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    quota: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    remaining: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
})
    .pipe(Schema.encodeKeys({
    anniversaryDate: "anniversary_date",
    quarterAnniversaryDate: "quarter_anniversary_date",
    quota: "quota",
    remaining: "remaining",
}))
    .pipe(T.ResponsePath("result"));
export const quotaRequestPriority = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: QuotaRequestPriorityRequest,
    output: QuotaRequestPriorityResponse,
    errors: [],
}));
export const ListScanConfigsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/scans/config",
}));
export const ListScanConfigsResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    result: Schema.Array(Schema.Struct({
        id: Schema.String,
        accountId: Schema.String,
        frequency: Schema.Number,
        ips: Schema.Array(Schema.String),
        ports: Schema.Array(Schema.String),
    }).pipe(Schema.encodeKeys({
        id: "id",
        accountId: "account_id",
        frequency: "frequency",
        ips: "ips",
        ports: "ports",
    }))),
});
export const listScanConfigs = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListScanConfigsRequest,
    output: ListScanConfigsResponse,
    errors: [],
    pagination: {
        mode: "single",
        items: "result",
    },
}));
export const CreateScanConfigRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    ips: Schema.Array(Schema.String),
    frequency: Schema.optional(Schema.Number),
    ports: Schema.optional(Schema.Array(Schema.String)),
}).pipe(T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/scans/config",
}));
export const CreateScanConfigResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    accountId: Schema.String,
    frequency: Schema.Number,
    ips: Schema.Array(Schema.String),
    ports: Schema.Array(Schema.String),
})
    .pipe(Schema.encodeKeys({
    id: "id",
    accountId: "account_id",
    frequency: "frequency",
    ips: "ips",
    ports: "ports",
}))
    .pipe(T.ResponsePath("result"));
export const createScanConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateScanConfigRequest,
    output: CreateScanConfigResponse,
    errors: [],
}));
export const PatchScanConfigRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    configId: Schema.String.pipe(T.HttpPath("configId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    frequency: Schema.optional(Schema.Number),
    ips: Schema.optional(Schema.Array(Schema.String)),
    ports: Schema.optional(Schema.Array(Schema.String)),
}).pipe(T.Http({
    method: "PATCH",
    path: "/accounts/{account_id}/cloudforce-one/scans/config/{configId}",
}));
export const PatchScanConfigResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    accountId: Schema.String,
    frequency: Schema.Number,
    ips: Schema.Array(Schema.String),
    ports: Schema.Array(Schema.String),
})
    .pipe(Schema.encodeKeys({
    id: "id",
    accountId: "account_id",
    frequency: "frequency",
    ips: "ips",
    ports: "ports",
}))
    .pipe(T.ResponsePath("result"));
export const patchScanConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PatchScanConfigRequest,
    output: PatchScanConfigResponse,
    errors: [],
}));
export const DeleteScanConfigRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    configId: Schema.String.pipe(T.HttpPath("configId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "DELETE",
    path: "/accounts/{account_id}/cloudforce-one/scans/config/{configId}",
}));
export const DeleteScanConfigResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result"));
export const deleteScanConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteScanConfigRequest,
    output: DeleteScanConfigResponse,
    errors: [],
}));
export const GetScanResultRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    configId: Schema.String.pipe(T.HttpPath("configId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/scans/results/{configId}",
}));
export const GetScanResultResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    "1.1.1.1": Schema.Array(Schema.Struct({
        number: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
        proto: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        status: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    })),
}).pipe(T.ResponsePath("result"));
export const getScanResult = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetScanResultRequest,
    output: GetScanResultResponse,
    errors: [],
}));
export const GetThreatEventRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    eventId: Schema.String.pipe(T.HttpPath("eventId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/events/{eventId}",
}));
export const GetThreatEventResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    attacker: Schema.String,
    attackerCountry: Schema.String,
    category: Schema.String,
    date: Schema.String,
    event: Schema.String,
    hasChildren: Schema.Boolean,
    indicator: Schema.String,
    indicatorType: Schema.String,
    indicatorTypeId: Schema.Number,
    killChain: Schema.Number,
    mitreAttack: Schema.Array(Schema.String),
    numReferenced: Schema.Number,
    numReferences: Schema.Number,
    rawId: Schema.String,
    referenced: Schema.Array(Schema.String),
    referencedIds: Schema.Array(Schema.Number),
    references: Schema.Array(Schema.String),
    referencesIds: Schema.Array(Schema.Number),
    tags: Schema.Array(Schema.String),
    targetCountry: Schema.String,
    targetIndustry: Schema.String,
    tlp: Schema.String,
    uuid: Schema.String,
    insight: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    releasabilityId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
});
export const getThreatEvent = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetThreatEventRequest,
    output: GetThreatEventResponse,
    errors: [],
}));
export const ListThreatEventsRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    datasetId: Schema.optional(Schema.Array(Schema.String)).pipe(T.HttpQuery("datasetId")),
    forceRefresh: Schema.optional(Schema.Boolean).pipe(T.HttpQuery("forceRefresh")),
    format: Schema.optional(Schema.Literals(["json", "stix2"])).pipe(T.HttpQuery("format")),
    order: Schema.optional(Schema.Literals(["asc", "desc"])).pipe(T.HttpQuery("order")),
    orderBy: Schema.optional(Schema.String).pipe(T.HttpQuery("orderBy")),
    page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
    pageSize: Schema.optional(Schema.Number).pipe(T.HttpQuery("pageSize")),
    search: Schema.optional(Schema.Array(Schema.Struct({
        field: Schema.optional(Schema.String),
        op: Schema.optional(Schema.Literals([
            "equals",
            "not",
            "gt",
            "gte",
            "lt",
            "lte",
            "like",
            "contains",
            "startsWith",
            "endsWith",
            "in",
            "find",
        ])),
        value: Schema.optional(Schema.Union([
            Schema.String,
            Schema.Number,
            Schema.Array(Schema.Union([Schema.String, Schema.Number])),
        ])),
    }))).pipe(T.HttpQuery("search")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/events",
}));
export const ListThreatEventsResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Array(Schema.Struct({
    attacker: Schema.String,
    attackerCountry: Schema.String,
    category: Schema.String,
    date: Schema.String,
    event: Schema.String,
    hasChildren: Schema.Boolean,
    indicator: Schema.String,
    indicatorType: Schema.String,
    indicatorTypeId: Schema.Number,
    killChain: Schema.Number,
    mitreAttack: Schema.Array(Schema.String),
    numReferenced: Schema.Number,
    numReferences: Schema.Number,
    rawId: Schema.String,
    referenced: Schema.Array(Schema.String),
    referencedIds: Schema.Array(Schema.Number),
    references: Schema.Array(Schema.String),
    referencesIds: Schema.Array(Schema.Number),
    tags: Schema.Array(Schema.String),
    targetCountry: Schema.String,
    targetIndustry: Schema.String,
    tlp: Schema.String,
    uuid: Schema.String,
    insight: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    releasabilityId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
}));
export const listThreatEvents = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListThreatEventsRequest,
    output: ListThreatEventsResponse,
    errors: [],
}));
export const CreateThreatEventRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    category: Schema.String,
    date: Schema.String,
    event: Schema.String,
    raw: Schema.Struct({
        data: Schema.Union([
            Schema.Record(Schema.String, Schema.Unknown),
            Schema.Null,
        ]),
        source: Schema.optional(Schema.String),
        tlp: Schema.optional(Schema.String),
    }),
    tlp: Schema.String,
    attacker: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    attackerCountry: Schema.optional(Schema.String),
    datasetId: Schema.optional(Schema.String),
    indicator: Schema.optional(Schema.String),
    indicators: Schema.optional(Schema.Array(Schema.Struct({
        indicatorType: Schema.String,
        value: Schema.String,
    }))),
    indicatorType: Schema.optional(Schema.String),
    insight: Schema.optional(Schema.String),
    tags: Schema.optional(Schema.Array(Schema.String)),
    targetCountry: Schema.optional(Schema.String),
    targetIndustry: Schema.optional(Schema.String),
    uuid: Schema.optional(Schema.String),
}).pipe(T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/events/create",
}));
export const CreateThreatEventResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    attacker: Schema.String,
    attackerCountry: Schema.String,
    category: Schema.String,
    date: Schema.String,
    event: Schema.String,
    hasChildren: Schema.Boolean,
    indicator: Schema.String,
    indicatorType: Schema.String,
    indicatorTypeId: Schema.Number,
    killChain: Schema.Number,
    mitreAttack: Schema.Array(Schema.String),
    numReferenced: Schema.Number,
    numReferences: Schema.Number,
    rawId: Schema.String,
    referenced: Schema.Array(Schema.String),
    referencedIds: Schema.Array(Schema.Number),
    references: Schema.Array(Schema.String),
    referencesIds: Schema.Array(Schema.Number),
    tags: Schema.Array(Schema.String),
    targetCountry: Schema.String,
    targetIndustry: Schema.String,
    tlp: Schema.String,
    uuid: Schema.String,
    insight: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    releasabilityId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
});
export const createThreatEvent = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateThreatEventRequest,
    output: CreateThreatEventResponse,
    errors: [],
}));
export const PatchThreatEventRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    eventId: Schema.String.pipe(T.HttpPath("eventId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    attacker: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    attackerCountry: Schema.optional(Schema.String),
    category: Schema.optional(Schema.String),
    createdAt: Schema.optional(Schema.String),
    datasetId: Schema.optional(Schema.String),
    date: Schema.optional(Schema.String),
    event: Schema.optional(Schema.String),
    indicator: Schema.optional(Schema.String),
    indicatorType: Schema.optional(Schema.String),
    insight: Schema.optional(Schema.String),
    raw: Schema.optional(Schema.Struct({
        data: Schema.optional(Schema.Union([
            Schema.Record(Schema.String, Schema.Unknown),
            Schema.Null,
        ])),
        source: Schema.optional(Schema.String),
        tlp: Schema.optional(Schema.String),
    })),
    targetCountry: Schema.optional(Schema.String),
    targetIndustry: Schema.optional(Schema.String),
    tlp: Schema.optional(Schema.String),
}).pipe(T.Http({
    method: "PATCH",
    path: "/accounts/{account_id}/cloudforce-one/events/{eventId}",
}));
export const PatchThreatEventResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    attacker: Schema.String,
    attackerCountry: Schema.String,
    category: Schema.String,
    date: Schema.String,
    event: Schema.String,
    hasChildren: Schema.Boolean,
    indicator: Schema.String,
    indicatorType: Schema.String,
    indicatorTypeId: Schema.Number,
    killChain: Schema.Number,
    mitreAttack: Schema.Array(Schema.String),
    numReferenced: Schema.Number,
    numReferences: Schema.Number,
    rawId: Schema.String,
    referenced: Schema.Array(Schema.String),
    referencedIds: Schema.Array(Schema.Number),
    references: Schema.Array(Schema.String),
    referencesIds: Schema.Array(Schema.Number),
    tags: Schema.Array(Schema.String),
    targetCountry: Schema.String,
    targetIndustry: Schema.String,
    tlp: Schema.String,
    uuid: Schema.String,
    insight: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    releasabilityId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
});
export const patchThreatEvent = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PatchThreatEventRequest,
    output: PatchThreatEventResponse,
    errors: [],
}));
export const DeleteThreatEventRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    eventId: Schema.String.pipe(T.HttpPath("eventId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "DELETE",
    path: "/accounts/{account_id}/cloudforce-one/events/{eventId}",
}));
export const DeleteThreatEventResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    uuid: Schema.String,
});
export const deleteThreatEvent = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteThreatEventRequest,
    output: DeleteThreatEventResponse,
    errors: [],
}));
export const BulkCreateThreatEventsRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    data: Schema.Array(Schema.Struct({
        category: Schema.String,
        date: Schema.String,
        event: Schema.String,
        raw: Schema.Struct({
            data: Schema.Union([
                Schema.Record(Schema.String, Schema.Unknown),
                Schema.Null,
            ]),
            source: Schema.optional(Schema.String),
            tlp: Schema.optional(Schema.String),
        }),
        tlp: Schema.String,
        accountId: Schema.optional(Schema.Number),
        attacker: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        attackerCountry: Schema.optional(Schema.String),
        datasetId: Schema.optional(Schema.String),
        indicator: Schema.optional(Schema.String),
        indicators: Schema.optional(Schema.Array(Schema.Struct({
            indicatorType: Schema.String,
            value: Schema.String,
        }))),
        indicatorType: Schema.optional(Schema.String),
        insight: Schema.optional(Schema.String),
        tags: Schema.optional(Schema.Array(Schema.String)),
        targetCountry: Schema.optional(Schema.String),
        targetIndustry: Schema.optional(Schema.String),
        uuid: Schema.optional(Schema.String),
    })),
    datasetId: Schema.String,
    preserveUuid: Schema.optional(Schema.Boolean),
}).pipe(T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/events/create/bulk",
}));
export const BulkCreateThreatEventsResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    createdEventsCount: Schema.Number,
    createdTagsCount: Schema.Number,
    errorCount: Schema.Number,
    queuedIndicatorsCount: Schema.Number,
    skippedEventsCount: Schema.Number,
    createBulkEventsRequestId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    errors: Schema.optional(Schema.Union([
        Schema.Array(Schema.Struct({
            error: Schema.String,
            eventIndex: Schema.Number,
        })),
        Schema.Null,
    ])),
});
export const bulkCreateThreatEvents = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: BulkCreateThreatEventsRequest,
    output: BulkCreateThreatEventsResponse,
    errors: [],
}));
export const ListThreatEventAttackersRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    datasetIds: Schema.optional(Schema.Array(Schema.String)).pipe(T.HttpQuery("datasetIds")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/events/attackers",
}));
export const ListThreatEventAttackersResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    items: Schema.Struct({
        type: Schema.String,
    }),
    type: Schema.String,
});
export const listThreatEventAttackers = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListThreatEventAttackersRequest,
    output: ListThreatEventAttackersResponse,
    errors: [],
}));
export const GetThreatEventCategoryRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    categoryId: Schema.String.pipe(T.HttpPath("categoryId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/events/categories/{categoryId}",
}));
export const GetThreatEventCategoryResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    killChain: Schema.Number,
    name: Schema.String,
    uuid: Schema.String,
    mitreAttack: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
    shortname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
});
export const getThreatEventCategory = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetThreatEventCategoryRequest,
    output: GetThreatEventCategoryResponse,
    errors: [],
}));
export const ListThreatEventCategoriesRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    datasetIds: Schema.optional(Schema.Array(Schema.String)).pipe(T.HttpQuery("datasetIds")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/events/categories",
}));
export const ListThreatEventCategoriesResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Array(Schema.Struct({
    killChain: Schema.Number,
    name: Schema.String,
    uuid: Schema.String,
    mitreAttack: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
    shortname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
}));
export const listThreatEventCategories = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListThreatEventCategoriesRequest,
    output: ListThreatEventCategoriesResponse,
    errors: [],
}));
export const CreateThreatEventCategoryRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    killChain: Schema.Number,
    name: Schema.String,
    mitreAttack: Schema.optional(Schema.Array(Schema.String)),
    shortname: Schema.optional(Schema.String),
}).pipe(T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/events/categories/create",
}));
export const CreateThreatEventCategoryResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    killChain: Schema.Number,
    name: Schema.String,
    uuid: Schema.String,
    mitreAttack: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
    shortname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
});
export const createThreatEventCategory = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateThreatEventCategoryRequest,
    output: CreateThreatEventCategoryResponse,
    errors: [],
}));
export const PatchThreatEventCategoryRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    categoryId: Schema.String.pipe(T.HttpPath("categoryId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    killChain: Schema.optional(Schema.Number),
    mitreAttack: Schema.optional(Schema.Array(Schema.String)),
    name: Schema.optional(Schema.String),
    shortname: Schema.optional(Schema.String),
}).pipe(T.Http({
    method: "PATCH",
    path: "/accounts/{account_id}/cloudforce-one/events/categories/{categoryId}",
}));
export const PatchThreatEventCategoryResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    killChain: Schema.Number,
    name: Schema.String,
    uuid: Schema.String,
    mitreAttack: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
    shortname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
});
export const patchThreatEventCategory = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PatchThreatEventCategoryRequest,
    output: PatchThreatEventCategoryResponse,
    errors: [],
}));
export const DeleteThreatEventCategoryRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    categoryId: Schema.String.pipe(T.HttpPath("categoryId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "DELETE",
    path: "/accounts/{account_id}/cloudforce-one/events/categories/{categoryId}",
}));
export const DeleteThreatEventCategoryResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    uuid: Schema.String,
});
export const deleteThreatEventCategory = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteThreatEventCategoryRequest,
    output: DeleteThreatEventCategoryResponse,
    errors: [],
}));
export const ListThreatEventCountriesRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/events/countries",
}));
export const ListThreatEventCountriesResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Array(Schema.Struct({
    result: Schema.Array(Schema.Struct({
        alpha3: Schema.String,
        name: Schema.String,
    })),
    success: Schema.String,
}));
export const listThreatEventCountries = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListThreatEventCountriesRequest,
    output: ListThreatEventCountriesResponse,
    errors: [],
}));
export const GetThreatEventDatasetRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    datasetId: Schema.String.pipe(T.HttpPath("datasetId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/events/dataset/{datasetId}",
}));
export const GetThreatEventDatasetResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    isPublic: Schema.Boolean,
    name: Schema.String,
    uuid: Schema.String,
});
export const getThreatEventDataset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetThreatEventDatasetRequest,
    output: GetThreatEventDatasetResponse,
    errors: [],
}));
export const ListThreatEventDatasetsRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/events/dataset",
}));
export const ListThreatEventDatasetsResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Array(Schema.Struct({
    isPublic: Schema.Boolean,
    name: Schema.String,
    uuid: Schema.String,
}));
export const listThreatEventDatasets = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListThreatEventDatasetsRequest,
    output: ListThreatEventDatasetsResponse,
    errors: [],
}));
export const CreateThreatEventDatasetRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    isPublic: Schema.Boolean,
    name: Schema.String,
}).pipe(T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/events/dataset/create",
}));
export const CreateThreatEventDatasetResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    isPublic: Schema.Boolean,
    name: Schema.String,
    uuid: Schema.String,
});
export const createThreatEventDataset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateThreatEventDatasetRequest,
    output: CreateThreatEventDatasetResponse,
    errors: [],
}));
export const PatchThreatEventDatasetRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    datasetId: Schema.String.pipe(T.HttpPath("datasetId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    isPublic: Schema.Boolean,
    name: Schema.String,
}).pipe(T.Http({
    method: "PATCH",
    path: "/accounts/{account_id}/cloudforce-one/events/dataset/{datasetId}",
}));
export const PatchThreatEventDatasetResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    isPublic: Schema.Boolean,
    name: Schema.String,
    uuid: Schema.String,
});
export const patchThreatEventDataset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PatchThreatEventDatasetRequest,
    output: PatchThreatEventDatasetResponse,
    errors: [],
}));
export const RawThreatEventDatasetRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    datasetId: Schema.String.pipe(T.HttpPath("datasetId")),
    eventId: Schema.String.pipe(T.HttpPath("eventId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/events/raw/{datasetId}/{eventId}",
}));
export const RawThreatEventDatasetResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    accountId: Schema.Number,
    created: Schema.String,
    data: Schema.Unknown,
    source: Schema.String,
    tlp: Schema.String,
});
export const rawThreatEventDataset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RawThreatEventDatasetRequest,
    output: RawThreatEventDatasetResponse,
    errors: [],
}));
export const CreateThreatEventEventTagRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    eventId: Schema.String.pipe(T.HttpPath("eventId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    tags: Schema.Array(Schema.String),
}).pipe(T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/events/event_tag/{eventId}/create",
}));
export const CreateThreatEventEventTagResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    success: Schema.Boolean,
}).pipe(T.ResponsePath("result"));
export const createThreatEventEventTag = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateThreatEventEventTagRequest,
    output: CreateThreatEventEventTagResponse,
    errors: [],
}));
export const DeleteThreatEventEventTagRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    eventId: Schema.String.pipe(T.HttpPath("eventId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "DELETE",
    path: "/accounts/{account_id}/cloudforce-one/events/event_tag/{eventId}",
}));
export const DeleteThreatEventEventTagResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    success: Schema.Boolean,
}).pipe(T.ResponsePath("result"));
export const deleteThreatEventEventTag = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteThreatEventEventTagRequest,
    output: DeleteThreatEventEventTagResponse,
    errors: [],
}));
export const ListThreatEventIndicatorTypesRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/events/indicatorTypes",
}));
export const ListThreatEventIndicatorTypesResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    items: Schema.Struct({
        type: Schema.String,
    }),
    type: Schema.String,
});
export const listThreatEventIndicatorTypes = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListThreatEventIndicatorTypesRequest,
    output: ListThreatEventIndicatorTypesResponse,
    errors: [],
}));
export const GetThreatEventRawRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    eventId: Schema.String.pipe(T.HttpPath("eventId")),
    rawId: Schema.String.pipe(T.HttpPath("rawId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/events/{eventId}/raw/{rawId}",
}));
export const GetThreatEventRawResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    accountId: Schema.Number,
    created: Schema.String,
    data: Schema.Unknown,
    source: Schema.String,
    tlp: Schema.String,
});
export const getThreatEventRaw = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetThreatEventRawRequest,
    output: GetThreatEventRawResponse,
    errors: [],
}));
export const PatchThreatEventRawRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    eventId: Schema.String.pipe(T.HttpPath("eventId")),
    rawId: Schema.String.pipe(T.HttpPath("rawId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    data: Schema.optional(Schema.Unknown),
    source: Schema.optional(Schema.String),
    tlp: Schema.optional(Schema.String),
}).pipe(T.Http({
    method: "PATCH",
    path: "/accounts/{account_id}/cloudforce-one/events/{eventId}/raw/{rawId}",
}));
export const PatchThreatEventRawResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    data: Schema.Unknown,
});
export const patchThreatEventRaw = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PatchThreatEventRawRequest,
    output: PatchThreatEventRawResponse,
    errors: [],
}));
export const DeleteThreatEventRelateRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    eventId: Schema.String.pipe(T.HttpPath("eventId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "DELETE",
    path: "/accounts/{account_id}/cloudforce-one/events/relate/{eventId}",
}));
export const DeleteThreatEventRelateResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    success: Schema.Boolean,
}).pipe(T.ResponsePath("result"));
export const deleteThreatEventRelate = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteThreatEventRelateRequest,
    output: DeleteThreatEventRelateResponse,
    errors: [],
}));
export const CreateThreatEventTagRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    value: Schema.String,
    activeDuration: Schema.optional(Schema.String),
    actorCategory: Schema.optional(Schema.String),
    aliasGroupNames: Schema.optional(Schema.Array(Schema.String)),
    aliasGroupNamesInternal: Schema.optional(Schema.Array(Schema.String)),
    analyticPriority: Schema.optional(Schema.Number),
    attributionConfidence: Schema.optional(Schema.String),
    attributionOrganization: Schema.optional(Schema.String),
    categoryUuid: Schema.optional(Schema.String),
    externalReferenceLinks: Schema.optional(Schema.Array(Schema.String)),
    internalDescription: Schema.optional(Schema.String),
    motive: Schema.optional(Schema.String),
    opsecLevel: Schema.optional(Schema.String),
    originCountryISO: Schema.optional(Schema.String),
    priority: Schema.optional(Schema.Number),
    sophisticationLevel: Schema.optional(Schema.String),
}).pipe(T.Http({
    method: "POST",
    path: "/accounts/{account_id}/cloudforce-one/events/tags/create",
}));
export const CreateThreatEventTagResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    uuid: Schema.String,
    value: Schema.String,
    activeDuration: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    actorCategory: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    aliasGroupNames: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
    aliasGroupNamesInternal: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
    analyticPriority: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    attributionConfidence: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    attributionOrganization: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    categoryName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    categoryUuid: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    externalReferenceLinks: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
    internalDescription: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    motive: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    opsecLevel: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    originCountryISO: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    priority: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    sophisticationLevel: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
});
export const createThreatEventTag = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateThreatEventTagRequest,
    output: CreateThreatEventTagResponse,
    errors: [],
}));
export const ListThreatEventTargetIndustriesRequest = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    datasetIds: Schema.optional(Schema.Array(Schema.String)).pipe(T.HttpQuery("datasetIds")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/cloudforce-one/events/targetIndustries",
}));
export const ListThreatEventTargetIndustriesResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    items: Schema.Struct({
        type: Schema.String,
    }),
    type: Schema.String,
});
export const listThreatEventTargetIndustries = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListThreatEventTargetIndustriesRequest,
    output: ListThreatEventTargetIndustriesResponse,
    errors: [],
}));
//# sourceMappingURL=cloudforce-one.js.map