1. Registry
  2. Packages
  3. Files.com
  4. API Docs
  5. HolidayCalendar
Viewing docs for Files.com v0.1.1
published on Thursday, Aug 20, 2026 by jschady
filescom logo
Viewing docs for Files.com v0.1.1
published on Thursday, Aug 20, 2026 by jschady

    A Holiday Calendar defines site-wide holiday dates and optional partial-day windows that scheduled resources skip.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as filescom from "pulumi-filescom";
    
    const exampleHolidayCalendar = new filescom.HolidayCalendar("example_holiday_calendar", {
        definition: {
            months: {
                "0": {
                    calculatedRules: [{
                        name: "Good Friday",
                        "function": "easter(year)",
                        functionModifier: -2,
                    }],
                },
                "1": {
                    fixedRules: [{
                        name: "New Year's Day",
                        mday: 1,
                        observed: "to_weekday_if_weekend(date)",
                    }],
                    weekdayRules: [{
                        name: "Third Monday",
                        week: 3,
                        wday: 1,
                    }],
                },
                "11": {
                    weekdayRules: [{
                        name: "Thanksgiving",
                        week: 4,
                        wday: 4,
                    }],
                },
                "12": {
                    fixedRules: [{
                        name: "Christmas Eve Early Close",
                        mday: 24,
                        startTime: "13:00",
                        endTime: "17:00",
                        yearRanges: {
                            from: 2026,
                        },
                    }],
                },
            },
        },
        name: "Company Holidays",
    });
    
    import pulumi
    import pulumi_filescom as filescom
    
    example_holiday_calendar = filescom.HolidayCalendar("example_holiday_calendar",
        definition={
            "months": {
                "0": {
                    "calculated_rules": [{
                        "name": "Good Friday",
                        "function": "easter(year)",
                        "function_modifier": -2,
                    }],
                },
                "1": {
                    "fixed_rules": [{
                        "name": "New Year's Day",
                        "mday": 1,
                        "observed": "to_weekday_if_weekend(date)",
                    }],
                    "weekday_rules": [{
                        "name": "Third Monday",
                        "week": 3,
                        "wday": 1,
                    }],
                },
                "11": {
                    "weekday_rules": [{
                        "name": "Thanksgiving",
                        "week": 4,
                        "wday": 4,
                    }],
                },
                "12": {
                    "fixed_rules": [{
                        "name": "Christmas Eve Early Close",
                        "mday": 24,
                        "start_time": "13:00",
                        "end_time": "17:00",
                        "year_ranges": {
                            "from_": 2026,
                        },
                    }],
                },
            },
        },
        name="Company Holidays")
    
    package main
    
    import (
    	"github.com/jschady/pulumi-filescom/sdk/go/filescom"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := filescom.NewHolidayCalendar(ctx, "example_holiday_calendar", &filescom.HolidayCalendarArgs{
    			Definition: &filescom.HolidayCalendarDefinitionArgs{
    				Months: filescom.HolidayCalendarDefinitionMonthsMap{
    					"0": &filescom.HolidayCalendarDefinitionMonthsArgs{
    						CalculatedRules: filescom.HolidayCalendarDefinitionMonthsCalculatedRuleArray{
    							&filescom.HolidayCalendarDefinitionMonthsCalculatedRuleArgs{
    								Name:             pulumi.String("Good Friday"),
    								Function:         pulumi.String("easter(year)"),
    								FunctionModifier: pulumi.Int(-2),
    							},
    						},
    					},
    					"1": &filescom.HolidayCalendarDefinitionMonthsArgs{
    						FixedRules: filescom.HolidayCalendarDefinitionMonthsFixedRuleArray{
    							&filescom.HolidayCalendarDefinitionMonthsFixedRuleArgs{
    								Name:     pulumi.String("New Year's Day"),
    								Mday:     pulumi.Int(1),
    								Observed: pulumi.String("to_weekday_if_weekend(date)"),
    							},
    						},
    						WeekdayRules: filescom.HolidayCalendarDefinitionMonthsWeekdayRuleArray{
    							&filescom.HolidayCalendarDefinitionMonthsWeekdayRuleArgs{
    								Name: pulumi.String("Third Monday"),
    								Week: pulumi.Int(3),
    								Wday: pulumi.Int(1),
    							},
    						},
    					},
    					"11": &filescom.HolidayCalendarDefinitionMonthsArgs{
    						WeekdayRules: filescom.HolidayCalendarDefinitionMonthsWeekdayRuleArray{
    							&filescom.HolidayCalendarDefinitionMonthsWeekdayRuleArgs{
    								Name: pulumi.String("Thanksgiving"),
    								Week: pulumi.Int(4),
    								Wday: pulumi.Int(4),
    							},
    						},
    					},
    					"12": &filescom.HolidayCalendarDefinitionMonthsArgs{
    						FixedRules: filescom.HolidayCalendarDefinitionMonthsFixedRuleArray{
    							&filescom.HolidayCalendarDefinitionMonthsFixedRuleArgs{
    								Name:      pulumi.String("Christmas Eve Early Close"),
    								Mday:      pulumi.Int(24),
    								StartTime: pulumi.String("13:00"),
    								EndTime:   pulumi.String("17:00"),
    								YearRanges: &filescom.HolidayCalendarDefinitionMonthsFixedRuleYearRangesArgs{
    									From: pulumi.Int(2026),
    								},
    							},
    						},
    					},
    				},
    			},
    			Name: pulumi.String("Company Holidays"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Filescom = Jschady.Filescom;
    
    return await Deployment.RunAsync(() => 
    {
        var exampleHolidayCalendar = new Filescom.HolidayCalendar("example_holiday_calendar", new()
        {
            Definition = new Filescom.Inputs.HolidayCalendarDefinitionArgs
            {
                Months = 
                {
                    { "0", new Filescom.Inputs.HolidayCalendarDefinitionMonthsArgs
                    {
                        CalculatedRules = new[]
                        {
                            new Filescom.Inputs.HolidayCalendarDefinitionMonthsCalculatedRuleArgs
                            {
                                Name = "Good Friday",
                                Function = "easter(year)",
                                FunctionModifier = -2,
                            },
                        },
                    } },
                    { "1", new Filescom.Inputs.HolidayCalendarDefinitionMonthsArgs
                    {
                        FixedRules = new[]
                        {
                            new Filescom.Inputs.HolidayCalendarDefinitionMonthsFixedRuleArgs
                            {
                                Name = "New Year's Day",
                                Mday = 1,
                                Observed = "to_weekday_if_weekend(date)",
                            },
                        },
                        WeekdayRules = new[]
                        {
                            new Filescom.Inputs.HolidayCalendarDefinitionMonthsWeekdayRuleArgs
                            {
                                Name = "Third Monday",
                                Week = 3,
                                Wday = 1,
                            },
                        },
                    } },
                    { "11", new Filescom.Inputs.HolidayCalendarDefinitionMonthsArgs
                    {
                        WeekdayRules = new[]
                        {
                            new Filescom.Inputs.HolidayCalendarDefinitionMonthsWeekdayRuleArgs
                            {
                                Name = "Thanksgiving",
                                Week = 4,
                                Wday = 4,
                            },
                        },
                    } },
                    { "12", new Filescom.Inputs.HolidayCalendarDefinitionMonthsArgs
                    {
                        FixedRules = new[]
                        {
                            new Filescom.Inputs.HolidayCalendarDefinitionMonthsFixedRuleArgs
                            {
                                Name = "Christmas Eve Early Close",
                                Mday = 24,
                                StartTime = "13:00",
                                EndTime = "17:00",
                                YearRanges = new Filescom.Inputs.HolidayCalendarDefinitionMonthsFixedRuleYearRangesArgs
                                {
                                    From = 2026,
                                },
                            },
                        },
                    } },
                },
            },
            Name = "Company Holidays",
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.filescom.HolidayCalendar;
    import com.pulumi.filescom.HolidayCalendarArgs;
    import com.pulumi.filescom.inputs.HolidayCalendarDefinitionArgs;
    import com.pulumi.filescom.inputs.HolidayCalendarDefinitionMonthsArgs;
    import com.pulumi.filescom.inputs.HolidayCalendarDefinitionMonthsCalculatedRuleArgs;
    import com.pulumi.filescom.inputs.HolidayCalendarDefinitionMonthsFixedRuleArgs;
    import com.pulumi.filescom.inputs.HolidayCalendarDefinitionMonthsWeekdayRuleArgs;
    import com.pulumi.filescom.inputs.HolidayCalendarDefinitionMonthsFixedRuleYearRangesArgs;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var exampleHolidayCalendar = new HolidayCalendar("exampleHolidayCalendar", HolidayCalendarArgs.builder()
                .definition(HolidayCalendarDefinitionArgs.builder()
                    .months(Map.ofEntries(
                        Map.entry("0", HolidayCalendarDefinitionMonthsArgs.builder()
                            .calculatedRules(HolidayCalendarDefinitionMonthsCalculatedRuleArgs.builder()
                                .name("Good Friday")
                                .function("easter(year)")
                                .functionModifier(-2)
                                .build())
                            .build()),
                        Map.entry("1", HolidayCalendarDefinitionMonthsArgs.builder()
                            .fixedRules(HolidayCalendarDefinitionMonthsFixedRuleArgs.builder()
                                .name("New Year's Day")
                                .mday(1)
                                .observed("to_weekday_if_weekend(date)")
                                .build())
                            .weekdayRules(HolidayCalendarDefinitionMonthsWeekdayRuleArgs.builder()
                                .name("Third Monday")
                                .week(3)
                                .wday(1)
                                .build())
                            .build()),
                        Map.entry("11", HolidayCalendarDefinitionMonthsArgs.builder()
                            .weekdayRules(HolidayCalendarDefinitionMonthsWeekdayRuleArgs.builder()
                                .name("Thanksgiving")
                                .week(4)
                                .wday(4)
                                .build())
                            .build()),
                        Map.entry("12", HolidayCalendarDefinitionMonthsArgs.builder()
                            .fixedRules(HolidayCalendarDefinitionMonthsFixedRuleArgs.builder()
                                .name("Christmas Eve Early Close")
                                .mday(24)
                                .startTime("13:00")
                                .endTime("17:00")
                                .yearRanges(HolidayCalendarDefinitionMonthsFixedRuleYearRangesArgs.builder()
                                    .from(2026)
                                    .build())
                                .build())
                            .build())
                    ))
                    .build())
                .name("Company Holidays")
                .build());
    
        }
    }
    
    resources:
      exampleHolidayCalendar:
        type: filescom:HolidayCalendar
        name: example_holiday_calendar
        properties:
          definition:
            months:
              '0':
                calculatedRules:
                  - name: Good Friday
                    function: easter(year)
                    functionModifier: -2
              '1':
                fixedRules:
                  - name: New Year's Day
                    mday: 1
                    observed: to_weekday_if_weekend(date)
                weekdayRules:
                  - name: Third Monday
                    week: 3
                    wday: 1
              '11':
                weekdayRules:
                  - name: Thanksgiving
                    week: 4
                    wday: 4
              '12':
                fixedRules:
                  - name: Christmas Eve Early Close
                    mday: 24
                    startTime: 13:00
                    endTime: 17:00
                    yearRanges:
                      from: 2026
          name: Company Holidays
    
    pulumi {
      required_providers {
        filescom = {
          source = "pulumi/filescom"
        }
      }
    }
    
    resource "filescom_holidaycalendar" "example_holiday_calendar" {
      definition = {
        months = {
          "0" = {
            calculated_rules = [{
              "name"             = "Good Friday"
              "function"         = "easter(year)"
              "functionModifier" = -2
            }]
          }
          "1" = {
            fixed_rules = [{
              "name"     = "New Year's Day"
              "mday"     = 1
              "observed" = "to_weekday_if_weekend(date)"
            }]
            weekday_rules = [{
              "name" = "Third Monday"
              "week" = 3
              "wday" = 1
            }]
          }
          "11" = {
            weekday_rules = [{
              "name" = "Thanksgiving"
              "week" = 4
              "wday" = 4
            }]
          }
          "12" = {
            fixed_rules = [{
              "name"      = "Christmas Eve Early Close"
              "mday"      = 24
              "startTime" = "13:00"
              "endTime"   = "17:00"
              "yearRanges" = {
                "from" = 2026
              }
            }]
          }
        }
      }
      name = "Company Holidays"
    }
    

    Create HolidayCalendar Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new HolidayCalendar(name: string, args: HolidayCalendarArgs, opts?: CustomResourceOptions);
    @overload
    def HolidayCalendar(resource_name: str,
                        args: HolidayCalendarArgs,
                        opts: Optional[ResourceOptions] = None)
    
    @overload
    def HolidayCalendar(resource_name: str,
                        opts: Optional[ResourceOptions] = None,
                        definition: Optional[HolidayCalendarDefinitionArgs] = None,
                        name: Optional[str] = None)
    func NewHolidayCalendar(ctx *Context, name string, args HolidayCalendarArgs, opts ...ResourceOption) (*HolidayCalendar, error)
    public HolidayCalendar(string name, HolidayCalendarArgs args, CustomResourceOptions? opts = null)
    public HolidayCalendar(String name, HolidayCalendarArgs args)
    public HolidayCalendar(String name, HolidayCalendarArgs args, CustomResourceOptions options)
    
    type: filescom:HolidayCalendar
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    resource "filescom_holiday_calendar" "name" {
        # resource properties
    }

    Parameters

    name string
    The unique name of the resource.
    args HolidayCalendarArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args HolidayCalendarArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args HolidayCalendarArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args HolidayCalendarArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args HolidayCalendarArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var holidayCalendarResource = new Filescom.HolidayCalendar("holidayCalendarResource", new()
    {
        Definition = new Filescom.Inputs.HolidayCalendarDefinitionArgs
        {
            Months = 
            {
                { "string", new Filescom.Inputs.HolidayCalendarDefinitionMonthsArgs
                {
                    CalculatedRules = new[]
                    {
                        new Filescom.Inputs.HolidayCalendarDefinitionMonthsCalculatedRuleArgs
                        {
                            Function = "string",
                            EndTime = "string",
                            FunctionModifier = 0,
                            Name = "string",
                            Observed = "string",
                            StartTime = "string",
                            YearRanges = new Filescom.Inputs.HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesArgs
                            {
                                Between = new Filescom.Inputs.HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesBetweenArgs
                                {
                                    End = 0,
                                    Start = 0,
                                },
                                From = 0,
                                Limiteds = new[]
                                {
                                    0,
                                },
                                Until = 0,
                            },
                        },
                    },
                    FixedRules = new[]
                    {
                        new Filescom.Inputs.HolidayCalendarDefinitionMonthsFixedRuleArgs
                        {
                            Mday = 0,
                            EndTime = "string",
                            Name = "string",
                            Observed = "string",
                            StartTime = "string",
                            YearRanges = new Filescom.Inputs.HolidayCalendarDefinitionMonthsFixedRuleYearRangesArgs
                            {
                                Between = new Filescom.Inputs.HolidayCalendarDefinitionMonthsFixedRuleYearRangesBetweenArgs
                                {
                                    End = 0,
                                    Start = 0,
                                },
                                From = 0,
                                Limiteds = new[]
                                {
                                    0,
                                },
                                Until = 0,
                            },
                        },
                    },
                    WeekdayRules = new[]
                    {
                        new Filescom.Inputs.HolidayCalendarDefinitionMonthsWeekdayRuleArgs
                        {
                            Wday = 0,
                            Week = 0,
                            EndTime = "string",
                            Name = "string",
                            Observed = "string",
                            StartTime = "string",
                            YearRanges = new Filescom.Inputs.HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesArgs
                            {
                                Between = new Filescom.Inputs.HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesBetweenArgs
                                {
                                    End = 0,
                                    Start = 0,
                                },
                                From = 0,
                                Limiteds = new[]
                                {
                                    0,
                                },
                                Until = 0,
                            },
                        },
                    },
                } },
            },
        },
        Name = "string",
    });
    
    example, err := filescom.NewHolidayCalendar(ctx, "holidayCalendarResource", &filescom.HolidayCalendarArgs{
    	Definition: &filescom.HolidayCalendarDefinitionArgs{
    		Months: filescom.HolidayCalendarDefinitionMonthsMap{
    			"string": &filescom.HolidayCalendarDefinitionMonthsArgs{
    				CalculatedRules: filescom.HolidayCalendarDefinitionMonthsCalculatedRuleArray{
    					&filescom.HolidayCalendarDefinitionMonthsCalculatedRuleArgs{
    						Function:         pulumi.String("string"),
    						EndTime:          pulumi.String("string"),
    						FunctionModifier: pulumi.Int(0),
    						Name:             pulumi.String("string"),
    						Observed:         pulumi.String("string"),
    						StartTime:        pulumi.String("string"),
    						YearRanges: &filescom.HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesArgs{
    							Between: &filescom.HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesBetweenArgs{
    								End:   pulumi.Int(0),
    								Start: pulumi.Int(0),
    							},
    							From: pulumi.Int(0),
    							Limiteds: pulumi.IntArray{
    								pulumi.Int(0),
    							},
    							Until: pulumi.Int(0),
    						},
    					},
    				},
    				FixedRules: filescom.HolidayCalendarDefinitionMonthsFixedRuleArray{
    					&filescom.HolidayCalendarDefinitionMonthsFixedRuleArgs{
    						Mday:      pulumi.Int(0),
    						EndTime:   pulumi.String("string"),
    						Name:      pulumi.String("string"),
    						Observed:  pulumi.String("string"),
    						StartTime: pulumi.String("string"),
    						YearRanges: &filescom.HolidayCalendarDefinitionMonthsFixedRuleYearRangesArgs{
    							Between: &filescom.HolidayCalendarDefinitionMonthsFixedRuleYearRangesBetweenArgs{
    								End:   pulumi.Int(0),
    								Start: pulumi.Int(0),
    							},
    							From: pulumi.Int(0),
    							Limiteds: pulumi.IntArray{
    								pulumi.Int(0),
    							},
    							Until: pulumi.Int(0),
    						},
    					},
    				},
    				WeekdayRules: filescom.HolidayCalendarDefinitionMonthsWeekdayRuleArray{
    					&filescom.HolidayCalendarDefinitionMonthsWeekdayRuleArgs{
    						Wday:      pulumi.Int(0),
    						Week:      pulumi.Int(0),
    						EndTime:   pulumi.String("string"),
    						Name:      pulumi.String("string"),
    						Observed:  pulumi.String("string"),
    						StartTime: pulumi.String("string"),
    						YearRanges: &filescom.HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesArgs{
    							Between: &filescom.HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesBetweenArgs{
    								End:   pulumi.Int(0),
    								Start: pulumi.Int(0),
    							},
    							From: pulumi.Int(0),
    							Limiteds: pulumi.IntArray{
    								pulumi.Int(0),
    							},
    							Until: pulumi.Int(0),
    						},
    					},
    				},
    			},
    		},
    	},
    	Name: pulumi.String("string"),
    })
    
    resource "filescom_holiday_calendar" "holidayCalendarResource" {
      lifecycle {
        create_before_destroy = true
      }
      definition = {
        months = {
          "string" = {
            calculated_rules = [{
              function          = "string"
              end_time          = "string"
              function_modifier = 0
              name              = "string"
              observed          = "string"
              start_time        = "string"
              year_ranges = {
                between = {
                  end   = 0
                  start = 0
                }
                from     = 0
                limiteds = [0]
                until    = 0
              }
            }]
            fixed_rules = [{
              mday       = 0
              end_time   = "string"
              name       = "string"
              observed   = "string"
              start_time = "string"
              year_ranges = {
                between = {
                  end   = 0
                  start = 0
                }
                from     = 0
                limiteds = [0]
                until    = 0
              }
            }]
            weekday_rules = [{
              wday       = 0
              week       = 0
              end_time   = "string"
              name       = "string"
              observed   = "string"
              start_time = "string"
              year_ranges = {
                between = {
                  end   = 0
                  start = 0
                }
                from     = 0
                limiteds = [0]
                until    = 0
              }
            }]
          }
        }
      }
      name = "string"
    }
    
    var holidayCalendarResource = new HolidayCalendar("holidayCalendarResource", HolidayCalendarArgs.builder()
        .definition(HolidayCalendarDefinitionArgs.builder()
            .months(Map.of("string", HolidayCalendarDefinitionMonthsArgs.builder()
                .calculatedRules(HolidayCalendarDefinitionMonthsCalculatedRuleArgs.builder()
                    .function("string")
                    .endTime("string")
                    .functionModifier(0)
                    .name("string")
                    .observed("string")
                    .startTime("string")
                    .yearRanges(HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesArgs.builder()
                        .between(HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesBetweenArgs.builder()
                            .end(0)
                            .start(0)
                            .build())
                        .from(0)
                        .limiteds(0)
                        .until(0)
                        .build())
                    .build())
                .fixedRules(HolidayCalendarDefinitionMonthsFixedRuleArgs.builder()
                    .mday(0)
                    .endTime("string")
                    .name("string")
                    .observed("string")
                    .startTime("string")
                    .yearRanges(HolidayCalendarDefinitionMonthsFixedRuleYearRangesArgs.builder()
                        .between(HolidayCalendarDefinitionMonthsFixedRuleYearRangesBetweenArgs.builder()
                            .end(0)
                            .start(0)
                            .build())
                        .from(0)
                        .limiteds(0)
                        .until(0)
                        .build())
                    .build())
                .weekdayRules(HolidayCalendarDefinitionMonthsWeekdayRuleArgs.builder()
                    .wday(0)
                    .week(0)
                    .endTime("string")
                    .name("string")
                    .observed("string")
                    .startTime("string")
                    .yearRanges(HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesArgs.builder()
                        .between(HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesBetweenArgs.builder()
                            .end(0)
                            .start(0)
                            .build())
                        .from(0)
                        .limiteds(0)
                        .until(0)
                        .build())
                    .build())
                .build()))
            .build())
        .name("string")
        .build());
    
    holiday_calendar_resource = filescom.HolidayCalendar("holidayCalendarResource",
        definition={
            "months": {
                "string": {
                    "calculated_rules": [{
                        "function": "string",
                        "end_time": "string",
                        "function_modifier": 0,
                        "name": "string",
                        "observed": "string",
                        "start_time": "string",
                        "year_ranges": {
                            "between": {
                                "end": 0,
                                "start": 0,
                            },
                            "from_": 0,
                            "limiteds": [0],
                            "until": 0,
                        },
                    }],
                    "fixed_rules": [{
                        "mday": 0,
                        "end_time": "string",
                        "name": "string",
                        "observed": "string",
                        "start_time": "string",
                        "year_ranges": {
                            "between": {
                                "end": 0,
                                "start": 0,
                            },
                            "from_": 0,
                            "limiteds": [0],
                            "until": 0,
                        },
                    }],
                    "weekday_rules": [{
                        "wday": 0,
                        "week": 0,
                        "end_time": "string",
                        "name": "string",
                        "observed": "string",
                        "start_time": "string",
                        "year_ranges": {
                            "between": {
                                "end": 0,
                                "start": 0,
                            },
                            "from_": 0,
                            "limiteds": [0],
                            "until": 0,
                        },
                    }],
                },
            },
        },
        name="string")
    
    const holidayCalendarResource = new filescom.HolidayCalendar("holidayCalendarResource", {
        definition: {
            months: {
                string: {
                    calculatedRules: [{
                        "function": "string",
                        endTime: "string",
                        functionModifier: 0,
                        name: "string",
                        observed: "string",
                        startTime: "string",
                        yearRanges: {
                            between: {
                                end: 0,
                                start: 0,
                            },
                            from: 0,
                            limiteds: [0],
                            until: 0,
                        },
                    }],
                    fixedRules: [{
                        mday: 0,
                        endTime: "string",
                        name: "string",
                        observed: "string",
                        startTime: "string",
                        yearRanges: {
                            between: {
                                end: 0,
                                start: 0,
                            },
                            from: 0,
                            limiteds: [0],
                            until: 0,
                        },
                    }],
                    weekdayRules: [{
                        wday: 0,
                        week: 0,
                        endTime: "string",
                        name: "string",
                        observed: "string",
                        startTime: "string",
                        yearRanges: {
                            between: {
                                end: 0,
                                start: 0,
                            },
                            from: 0,
                            limiteds: [0],
                            until: 0,
                        },
                    }],
                },
            },
        },
        name: "string",
    });
    
    type: filescom:HolidayCalendar
    properties:
        definition:
            months:
                string:
                    calculatedRules:
                        - endTime: string
                          function: string
                          functionModifier: 0
                          name: string
                          observed: string
                          startTime: string
                          yearRanges:
                            between:
                                end: 0
                                start: 0
                            from: 0
                            limiteds:
                                - 0
                            until: 0
                    fixedRules:
                        - endTime: string
                          mday: 0
                          name: string
                          observed: string
                          startTime: string
                          yearRanges:
                            between:
                                end: 0
                                start: 0
                            from: 0
                            limiteds:
                                - 0
                            until: 0
                    weekdayRules:
                        - endTime: string
                          name: string
                          observed: string
                          startTime: string
                          wday: 0
                          week: 0
                          yearRanges:
                            between:
                                end: 0
                                start: 0
                            from: 0
                            limiteds:
                                - 0
                            until: 0
        name: string
    

    HolidayCalendar Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The HolidayCalendar resource accepts the following input properties:

    Definition Jschady.Filescom.Inputs.HolidayCalendarDefinition
    Holiday rules for the calendar.
    Name string
    Holiday Calendar name.
    Definition HolidayCalendarDefinitionArgs
    Holiday rules for the calendar.
    Name string
    Holiday Calendar name.
    definition object
    Holiday rules for the calendar.
    name string
    Holiday Calendar name.
    definition HolidayCalendarDefinition
    Holiday rules for the calendar.
    name String
    Holiday Calendar name.
    definition HolidayCalendarDefinition
    Holiday rules for the calendar.
    name string
    Holiday Calendar name.
    definition HolidayCalendarDefinitionArgs
    Holiday rules for the calendar.
    name str
    Holiday Calendar name.
    definition Property Map
    Holiday rules for the calendar.
    name String
    Holiday Calendar name.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the HolidayCalendar resource produces the following output properties:

    CreatedAt string
    Creation time.
    Id string
    The provider-assigned unique ID for this managed resource.
    UpdatedAt string
    Last update time.
    CreatedAt string
    Creation time.
    Id string
    The provider-assigned unique ID for this managed resource.
    UpdatedAt string
    Last update time.
    created_at string
    Creation time.
    id string
    The provider-assigned unique ID for this managed resource.
    updated_at string
    Last update time.
    createdAt String
    Creation time.
    id String
    The provider-assigned unique ID for this managed resource.
    updatedAt String
    Last update time.
    createdAt string
    Creation time.
    id string
    The provider-assigned unique ID for this managed resource.
    updatedAt string
    Last update time.
    created_at str
    Creation time.
    id str
    The provider-assigned unique ID for this managed resource.
    updated_at str
    Last update time.
    createdAt String
    Creation time.
    id String
    The provider-assigned unique ID for this managed resource.
    updatedAt String
    Last update time.

    Look up Existing HolidayCalendar Resource

    Get an existing HolidayCalendar resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: HolidayCalendarState, opts?: CustomResourceOptions): HolidayCalendar
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            created_at: Optional[str] = None,
            definition: Optional[HolidayCalendarDefinitionArgs] = None,
            name: Optional[str] = None,
            updated_at: Optional[str] = None) -> HolidayCalendar
    func GetHolidayCalendar(ctx *Context, name string, id IDInput, state *HolidayCalendarState, opts ...ResourceOption) (*HolidayCalendar, error)
    public static HolidayCalendar Get(string name, Input<string> id, HolidayCalendarState? state, CustomResourceOptions? opts = null)
    public static HolidayCalendar get(String name, Output<String> id, HolidayCalendarState state, CustomResourceOptions options)
    resources:  _:    type: filescom:HolidayCalendar    get:      id: ${id}
    import {
      to = filescom_holiday_calendar.example
      id = "${id}"
    }
    
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    CreatedAt string
    Creation time.
    Definition Jschady.Filescom.Inputs.HolidayCalendarDefinition
    Holiday rules for the calendar.
    Name string
    Holiday Calendar name.
    UpdatedAt string
    Last update time.
    CreatedAt string
    Creation time.
    Definition HolidayCalendarDefinitionArgs
    Holiday rules for the calendar.
    Name string
    Holiday Calendar name.
    UpdatedAt string
    Last update time.
    created_at string
    Creation time.
    definition object
    Holiday rules for the calendar.
    name string
    Holiday Calendar name.
    updated_at string
    Last update time.
    createdAt String
    Creation time.
    definition HolidayCalendarDefinition
    Holiday rules for the calendar.
    name String
    Holiday Calendar name.
    updatedAt String
    Last update time.
    createdAt string
    Creation time.
    definition HolidayCalendarDefinition
    Holiday rules for the calendar.
    name string
    Holiday Calendar name.
    updatedAt string
    Last update time.
    created_at str
    Creation time.
    definition HolidayCalendarDefinitionArgs
    Holiday rules for the calendar.
    name str
    Holiday Calendar name.
    updated_at str
    Last update time.
    createdAt String
    Creation time.
    definition Property Map
    Holiday rules for the calendar.
    name String
    Holiday Calendar name.
    updatedAt String
    Last update time.

    Supporting Types

    HolidayCalendarDefinition, HolidayCalendarDefinitionArgs

    Months Dictionary<string, Jschady.Filescom.Inputs.HolidayCalendarDefinitionMonths>
    Keys 1 through 12 contain rules for that month. Key 0 contains calculated-date rules. At most 366 rules are allowed across all months.
    Months map[string]HolidayCalendarDefinitionMonths
    Keys 1 through 12 contain rules for that month. Key 0 contains calculated-date rules. At most 366 rules are allowed across all months.
    months map(object)
    Keys 1 through 12 contain rules for that month. Key 0 contains calculated-date rules. At most 366 rules are allowed across all months.
    months Map<String,HolidayCalendarDefinitionMonths>
    Keys 1 through 12 contain rules for that month. Key 0 contains calculated-date rules. At most 366 rules are allowed across all months.
    months {[key: string]: HolidayCalendarDefinitionMonths}
    Keys 1 through 12 contain rules for that month. Key 0 contains calculated-date rules. At most 366 rules are allowed across all months.
    months Mapping[str, HolidayCalendarDefinitionMonths]
    Keys 1 through 12 contain rules for that month. Key 0 contains calculated-date rules. At most 366 rules are allowed across all months.
    months Map<Property Map>
    Keys 1 through 12 contain rules for that month. Key 0 contains calculated-date rules. At most 366 rules are allowed across all months.

    HolidayCalendarDefinitionMonths, HolidayCalendarDefinitionMonthsArgs

    HolidayCalendarDefinitionMonthsCalculatedRule, HolidayCalendarDefinitionMonthsCalculatedRuleArgs

    Function string
    Supported calculated-date function.
    EndTime string
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    FunctionModifier int
    Number of days to add to or subtract from the calculated date.
    Name string
    Optional rule name.
    Observed string
    Optional function used to move the selected date when it falls on a weekend.
    StartTime string
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    YearRanges Jschady.Filescom.Inputs.HolidayCalendarDefinitionMonthsCalculatedRuleYearRanges
    Optional inclusive year restriction.
    Function string
    Supported calculated-date function.
    EndTime string
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    FunctionModifier int
    Number of days to add to or subtract from the calculated date.
    Name string
    Optional rule name.
    Observed string
    Optional function used to move the selected date when it falls on a weekend.
    StartTime string
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    YearRanges HolidayCalendarDefinitionMonthsCalculatedRuleYearRanges
    Optional inclusive year restriction.
    function string
    Supported calculated-date function.
    end_time string
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    function_modifier number
    Number of days to add to or subtract from the calculated date.
    name string
    Optional rule name.
    observed string
    Optional function used to move the selected date when it falls on a weekend.
    start_time string
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    year_ranges object
    Optional inclusive year restriction.
    function String
    Supported calculated-date function.
    endTime String
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    functionModifier Integer
    Number of days to add to or subtract from the calculated date.
    name String
    Optional rule name.
    observed String
    Optional function used to move the selected date when it falls on a weekend.
    startTime String
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    yearRanges HolidayCalendarDefinitionMonthsCalculatedRuleYearRanges
    Optional inclusive year restriction.
    function string
    Supported calculated-date function.
    endTime string
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    functionModifier number
    Number of days to add to or subtract from the calculated date.
    name string
    Optional rule name.
    observed string
    Optional function used to move the selected date when it falls on a weekend.
    startTime string
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    yearRanges HolidayCalendarDefinitionMonthsCalculatedRuleYearRanges
    Optional inclusive year restriction.
    function str
    Supported calculated-date function.
    end_time str
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    function_modifier int
    Number of days to add to or subtract from the calculated date.
    name str
    Optional rule name.
    observed str
    Optional function used to move the selected date when it falls on a weekend.
    start_time str
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    year_ranges HolidayCalendarDefinitionMonthsCalculatedRuleYearRanges
    Optional inclusive year restriction.
    function String
    Supported calculated-date function.
    endTime String
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    functionModifier Number
    Number of days to add to or subtract from the calculated date.
    name String
    Optional rule name.
    observed String
    Optional function used to move the selected date when it falls on a weekend.
    startTime String
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    yearRanges Property Map
    Optional inclusive year restriction.

    HolidayCalendarDefinitionMonthsCalculatedRuleYearRanges, HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesArgs

    Between Jschady.Filescom.Inputs.HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesBetween
    Required start and end years.
    From int
    First year in which the rule applies.
    Limiteds List<int>
    Years in which the rule applies.
    Until int
    Last year in which the rule applies.
    Between HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesBetween
    Required start and end years.
    From int
    First year in which the rule applies.
    Limiteds []int
    Years in which the rule applies.
    Until int
    Last year in which the rule applies.
    between object
    Required start and end years.
    from number
    First year in which the rule applies.
    limiteds list(number)
    Years in which the rule applies.
    until number
    Last year in which the rule applies.
    between HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesBetween
    Required start and end years.
    from Integer
    First year in which the rule applies.
    limiteds List<Integer>
    Years in which the rule applies.
    until Integer
    Last year in which the rule applies.
    between HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesBetween
    Required start and end years.
    from number
    First year in which the rule applies.
    limiteds number[]
    Years in which the rule applies.
    until number
    Last year in which the rule applies.
    between HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesBetween
    Required start and end years.
    from_ int
    First year in which the rule applies.
    limiteds Sequence[int]
    Years in which the rule applies.
    until int
    Last year in which the rule applies.
    between Property Map
    Required start and end years.
    from Number
    First year in which the rule applies.
    limiteds List<Number>
    Years in which the rule applies.
    until Number
    Last year in which the rule applies.

    HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesBetween, HolidayCalendarDefinitionMonthsCalculatedRuleYearRangesBetweenArgs

    End int
    Start int
    End int
    Start int
    end number
    start number
    end Integer
    start Integer
    end number
    start number
    end int
    start int
    end Number
    start Number

    HolidayCalendarDefinitionMonthsFixedRule, HolidayCalendarDefinitionMonthsFixedRuleArgs

    Mday int
    Day of the month. Must be valid for the selected month.
    EndTime string
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    Name string
    Optional rule name.
    Observed string
    Optional function used to move the selected date when it falls on a weekend.
    StartTime string
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    YearRanges Jschady.Filescom.Inputs.HolidayCalendarDefinitionMonthsFixedRuleYearRanges
    Optional inclusive year restriction.
    Mday int
    Day of the month. Must be valid for the selected month.
    EndTime string
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    Name string
    Optional rule name.
    Observed string
    Optional function used to move the selected date when it falls on a weekend.
    StartTime string
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    YearRanges HolidayCalendarDefinitionMonthsFixedRuleYearRanges
    Optional inclusive year restriction.
    mday number
    Day of the month. Must be valid for the selected month.
    end_time string
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    name string
    Optional rule name.
    observed string
    Optional function used to move the selected date when it falls on a weekend.
    start_time string
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    year_ranges object
    Optional inclusive year restriction.
    mday Integer
    Day of the month. Must be valid for the selected month.
    endTime String
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    name String
    Optional rule name.
    observed String
    Optional function used to move the selected date when it falls on a weekend.
    startTime String
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    yearRanges HolidayCalendarDefinitionMonthsFixedRuleYearRanges
    Optional inclusive year restriction.
    mday number
    Day of the month. Must be valid for the selected month.
    endTime string
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    name string
    Optional rule name.
    observed string
    Optional function used to move the selected date when it falls on a weekend.
    startTime string
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    yearRanges HolidayCalendarDefinitionMonthsFixedRuleYearRanges
    Optional inclusive year restriction.
    mday int
    Day of the month. Must be valid for the selected month.
    end_time str
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    name str
    Optional rule name.
    observed str
    Optional function used to move the selected date when it falls on a weekend.
    start_time str
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    year_ranges HolidayCalendarDefinitionMonthsFixedRuleYearRanges
    Optional inclusive year restriction.
    mday Number
    Day of the month. Must be valid for the selected month.
    endTime String
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    name String
    Optional rule name.
    observed String
    Optional function used to move the selected date when it falls on a weekend.
    startTime String
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    yearRanges Property Map
    Optional inclusive year restriction.

    HolidayCalendarDefinitionMonthsFixedRuleYearRanges, HolidayCalendarDefinitionMonthsFixedRuleYearRangesArgs

    Between Jschady.Filescom.Inputs.HolidayCalendarDefinitionMonthsFixedRuleYearRangesBetween
    Required start and end years.
    From int
    First year in which the rule applies.
    Limiteds List<int>
    Years in which the rule applies.
    Until int
    Last year in which the rule applies.
    Between HolidayCalendarDefinitionMonthsFixedRuleYearRangesBetween
    Required start and end years.
    From int
    First year in which the rule applies.
    Limiteds []int
    Years in which the rule applies.
    Until int
    Last year in which the rule applies.
    between object
    Required start and end years.
    from number
    First year in which the rule applies.
    limiteds list(number)
    Years in which the rule applies.
    until number
    Last year in which the rule applies.
    between HolidayCalendarDefinitionMonthsFixedRuleYearRangesBetween
    Required start and end years.
    from Integer
    First year in which the rule applies.
    limiteds List<Integer>
    Years in which the rule applies.
    until Integer
    Last year in which the rule applies.
    between HolidayCalendarDefinitionMonthsFixedRuleYearRangesBetween
    Required start and end years.
    from number
    First year in which the rule applies.
    limiteds number[]
    Years in which the rule applies.
    until number
    Last year in which the rule applies.
    between HolidayCalendarDefinitionMonthsFixedRuleYearRangesBetween
    Required start and end years.
    from_ int
    First year in which the rule applies.
    limiteds Sequence[int]
    Years in which the rule applies.
    until int
    Last year in which the rule applies.
    between Property Map
    Required start and end years.
    from Number
    First year in which the rule applies.
    limiteds List<Number>
    Years in which the rule applies.
    until Number
    Last year in which the rule applies.

    HolidayCalendarDefinitionMonthsFixedRuleYearRangesBetween, HolidayCalendarDefinitionMonthsFixedRuleYearRangesBetweenArgs

    End int
    Start int
    End int
    Start int
    end number
    start number
    end Integer
    start Integer
    end number
    start number
    end int
    start int
    end Number
    start Number

    HolidayCalendarDefinitionMonthsWeekdayRule, HolidayCalendarDefinitionMonthsWeekdayRuleArgs

    Wday int
    Day of the week, where 0 is Sunday and 6 is Saturday.
    Week int
    Occurrence of the weekday in the month. Negative values count from the end of the month.
    EndTime string
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    Name string
    Optional rule name.
    Observed string
    Optional function used to move the selected date when it falls on a weekend.
    StartTime string
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    YearRanges Jschady.Filescom.Inputs.HolidayCalendarDefinitionMonthsWeekdayRuleYearRanges
    Optional inclusive year restriction.
    Wday int
    Day of the week, where 0 is Sunday and 6 is Saturday.
    Week int
    Occurrence of the weekday in the month. Negative values count from the end of the month.
    EndTime string
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    Name string
    Optional rule name.
    Observed string
    Optional function used to move the selected date when it falls on a weekend.
    StartTime string
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    YearRanges HolidayCalendarDefinitionMonthsWeekdayRuleYearRanges
    Optional inclusive year restriction.
    wday number
    Day of the week, where 0 is Sunday and 6 is Saturday.
    week number
    Occurrence of the weekday in the month. Negative values count from the end of the month.
    end_time string
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    name string
    Optional rule name.
    observed string
    Optional function used to move the selected date when it falls on a weekend.
    start_time string
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    year_ranges object
    Optional inclusive year restriction.
    wday Integer
    Day of the week, where 0 is Sunday and 6 is Saturday.
    week Integer
    Occurrence of the weekday in the month. Negative values count from the end of the month.
    endTime String
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    name String
    Optional rule name.
    observed String
    Optional function used to move the selected date when it falls on a weekend.
    startTime String
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    yearRanges HolidayCalendarDefinitionMonthsWeekdayRuleYearRanges
    Optional inclusive year restriction.
    wday number
    Day of the week, where 0 is Sunday and 6 is Saturday.
    week number
    Occurrence of the weekday in the month. Negative values count from the end of the month.
    endTime string
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    name string
    Optional rule name.
    observed string
    Optional function used to move the selected date when it falls on a weekend.
    startTime string
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    yearRanges HolidayCalendarDefinitionMonthsWeekdayRuleYearRanges
    Optional inclusive year restriction.
    wday int
    Day of the week, where 0 is Sunday and 6 is Saturday.
    week int
    Occurrence of the weekday in the month. Negative values count from the end of the month.
    end_time str
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    name str
    Optional rule name.
    observed str
    Optional function used to move the selected date when it falls on a weekend.
    start_time str
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    year_ranges HolidayCalendarDefinitionMonthsWeekdayRuleYearRanges
    Optional inclusive year restriction.
    wday Number
    Day of the week, where 0 is Sunday and 6 is Saturday.
    week Number
    Occurrence of the weekday in the month. Negative values count from the end of the month.
    endTime String
    Exclusive end of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be later than start_time.
    name String
    Optional rule name.
    observed String
    Optional function used to move the selected date when it falls on a weekend.
    startTime String
    Inclusive start of a partial-day window in 24-hour HH:MM or HH:MM:SS format. Must be earlier than end_time.
    yearRanges Property Map
    Optional inclusive year restriction.

    HolidayCalendarDefinitionMonthsWeekdayRuleYearRanges, HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesArgs

    Between Jschady.Filescom.Inputs.HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesBetween
    Required start and end years.
    From int
    First year in which the rule applies.
    Limiteds List<int>
    Years in which the rule applies.
    Until int
    Last year in which the rule applies.
    Between HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesBetween
    Required start and end years.
    From int
    First year in which the rule applies.
    Limiteds []int
    Years in which the rule applies.
    Until int
    Last year in which the rule applies.
    between object
    Required start and end years.
    from number
    First year in which the rule applies.
    limiteds list(number)
    Years in which the rule applies.
    until number
    Last year in which the rule applies.
    between HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesBetween
    Required start and end years.
    from Integer
    First year in which the rule applies.
    limiteds List<Integer>
    Years in which the rule applies.
    until Integer
    Last year in which the rule applies.
    between HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesBetween
    Required start and end years.
    from number
    First year in which the rule applies.
    limiteds number[]
    Years in which the rule applies.
    until number
    Last year in which the rule applies.
    between HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesBetween
    Required start and end years.
    from_ int
    First year in which the rule applies.
    limiteds Sequence[int]
    Years in which the rule applies.
    until int
    Last year in which the rule applies.
    between Property Map
    Required start and end years.
    from Number
    First year in which the rule applies.
    limiteds List<Number>
    Years in which the rule applies.
    until Number
    Last year in which the rule applies.

    HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesBetween, HolidayCalendarDefinitionMonthsWeekdayRuleYearRangesBetweenArgs

    End int
    Start int
    End int
    Start int
    end number
    start number
    end Integer
    start Integer
    end number
    start number
    end int
    start int
    end Number
    start Number

    Import

    The pulumi import command can be used, for example:

    Holiday Calendars can be imported by specifying the id.

    $ pulumi import filescom:index/holidayCalendar:HolidayCalendar example_holiday_calendar 1
    

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    filescom jschady/pulumi-filescom
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the filescom Terraform Provider.
    filescom logo
    Viewing docs for Files.com v0.1.1
    published on Thursday, Aug 20, 2026 by jschady

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial